#[allow(clippy::unnecessary_wraps)]
pub fn parse_add_attributes_to_findings_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::AddAttributesToFindingsOutput,
crate::error::AddAttributesToFindingsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::AddAttributesToFindingsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::AddAttributesToFindingsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::AddAttributesToFindingsError { meta: generic, kind: crate::error::AddAttributesToFindingsErrorKind::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::AddAttributesToFindingsError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"InternalException" => crate::error::AddAttributesToFindingsError { meta: generic, kind: crate::error::AddAttributesToFindingsErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AddAttributesToFindingsError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"InvalidInputException" => crate::error::AddAttributesToFindingsError { meta: generic, kind: crate::error::AddAttributesToFindingsErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AddAttributesToFindingsError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"NoSuchEntityException" => crate::error::AddAttributesToFindingsError { meta: generic, kind: crate::error::AddAttributesToFindingsErrorKind::NoSuchEntityException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::no_such_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_no_such_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AddAttributesToFindingsError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ServiceTemporarilyUnavailableException" => crate::error::AddAttributesToFindingsError { meta: generic, kind: crate::error::AddAttributesToFindingsErrorKind::ServiceTemporarilyUnavailableException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::service_temporarily_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_temporarily_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AddAttributesToFindingsError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
_ => crate::error::AddAttributesToFindingsError::generic(generic)
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_add_attributes_to_findings_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::AddAttributesToFindingsOutput,
crate::error::AddAttributesToFindingsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::add_attributes_to_findings_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_add_attributes_to_findings(
response.body().as_ref(),
output,
)
.map_err(crate::error::AddAttributesToFindingsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_assessment_target_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateAssessmentTargetOutput,
crate::error::CreateAssessmentTargetError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateAssessmentTargetError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::CreateAssessmentTargetError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::CreateAssessmentTargetError { meta: generic, kind: crate::error::CreateAssessmentTargetErrorKind::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::CreateAssessmentTargetError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"InternalException" => crate::error::CreateAssessmentTargetError { meta: generic, kind: crate::error::CreateAssessmentTargetErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateAssessmentTargetError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"InvalidCrossAccountRoleException" => crate::error::CreateAssessmentTargetError { meta: generic, kind: crate::error::CreateAssessmentTargetErrorKind::InvalidCrossAccountRoleException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::invalid_cross_account_role_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_cross_account_role_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateAssessmentTargetError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"InvalidInputException" => crate::error::CreateAssessmentTargetError { meta: generic, kind: crate::error::CreateAssessmentTargetErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateAssessmentTargetError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"LimitExceededException" => crate::error::CreateAssessmentTargetError { meta: generic, kind: crate::error::CreateAssessmentTargetErrorKind::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::CreateAssessmentTargetError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"NoSuchEntityException" => crate::error::CreateAssessmentTargetError { meta: generic, kind: crate::error::CreateAssessmentTargetErrorKind::NoSuchEntityException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::no_such_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_no_such_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateAssessmentTargetError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ServiceTemporarilyUnavailableException" => crate::error::CreateAssessmentTargetError { meta: generic, kind: crate::error::CreateAssessmentTargetErrorKind::ServiceTemporarilyUnavailableException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::service_temporarily_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_temporarily_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateAssessmentTargetError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
_ => crate::error::CreateAssessmentTargetError::generic(generic)
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_assessment_target_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateAssessmentTargetOutput,
crate::error::CreateAssessmentTargetError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_assessment_target_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_assessment_target(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateAssessmentTargetError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_assessment_template_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateAssessmentTemplateOutput,
crate::error::CreateAssessmentTemplateError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateAssessmentTemplateError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::CreateAssessmentTemplateError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::CreateAssessmentTemplateError { meta: generic, kind: crate::error::CreateAssessmentTemplateErrorKind::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::CreateAssessmentTemplateError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"InternalException" => crate::error::CreateAssessmentTemplateError { meta: generic, kind: crate::error::CreateAssessmentTemplateErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateAssessmentTemplateError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"InvalidInputException" => crate::error::CreateAssessmentTemplateError { meta: generic, kind: crate::error::CreateAssessmentTemplateErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateAssessmentTemplateError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"LimitExceededException" => crate::error::CreateAssessmentTemplateError { meta: generic, kind: crate::error::CreateAssessmentTemplateErrorKind::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::CreateAssessmentTemplateError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"NoSuchEntityException" => crate::error::CreateAssessmentTemplateError { meta: generic, kind: crate::error::CreateAssessmentTemplateErrorKind::NoSuchEntityException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::no_such_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_no_such_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateAssessmentTemplateError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ServiceTemporarilyUnavailableException" => crate::error::CreateAssessmentTemplateError { meta: generic, kind: crate::error::CreateAssessmentTemplateErrorKind::ServiceTemporarilyUnavailableException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::service_temporarily_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_temporarily_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateAssessmentTemplateError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
_ => crate::error::CreateAssessmentTemplateError::generic(generic)
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_assessment_template_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateAssessmentTemplateOutput,
crate::error::CreateAssessmentTemplateError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_assessment_template_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_assessment_template(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateAssessmentTemplateError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_exclusions_preview_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateExclusionsPreviewOutput,
crate::error::CreateExclusionsPreviewError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateExclusionsPreviewError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::CreateExclusionsPreviewError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::CreateExclusionsPreviewError { meta: generic, kind: crate::error::CreateExclusionsPreviewErrorKind::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::CreateExclusionsPreviewError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"InternalException" => crate::error::CreateExclusionsPreviewError { meta: generic, kind: crate::error::CreateExclusionsPreviewErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateExclusionsPreviewError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"InvalidInputException" => crate::error::CreateExclusionsPreviewError { meta: generic, kind: crate::error::CreateExclusionsPreviewErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateExclusionsPreviewError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"NoSuchEntityException" => crate::error::CreateExclusionsPreviewError { meta: generic, kind: crate::error::CreateExclusionsPreviewErrorKind::NoSuchEntityException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::no_such_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_no_such_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateExclusionsPreviewError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"PreviewGenerationInProgressException" => crate::error::CreateExclusionsPreviewError { meta: generic, kind: crate::error::CreateExclusionsPreviewErrorKind::PreviewGenerationInProgressException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::preview_generation_in_progress_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_preview_generation_in_progress_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateExclusionsPreviewError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ServiceTemporarilyUnavailableException" => crate::error::CreateExclusionsPreviewError { meta: generic, kind: crate::error::CreateExclusionsPreviewErrorKind::ServiceTemporarilyUnavailableException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::service_temporarily_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_temporarily_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateExclusionsPreviewError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
_ => crate::error::CreateExclusionsPreviewError::generic(generic)
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_exclusions_preview_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateExclusionsPreviewOutput,
crate::error::CreateExclusionsPreviewError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_exclusions_preview_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_exclusions_preview(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateExclusionsPreviewError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_resource_group_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateResourceGroupOutput,
crate::error::CreateResourceGroupError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateResourceGroupError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateResourceGroupError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::CreateResourceGroupError {
meta: generic,
kind: crate::error::CreateResourceGroupErrorKind::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::CreateResourceGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalException" => {
crate::error::CreateResourceGroupError {
meta: generic,
kind: crate::error::CreateResourceGroupErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateResourceGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidInputException" => crate::error::CreateResourceGroupError {
meta: generic,
kind: crate::error::CreateResourceGroupErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateResourceGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateResourceGroupError {
meta: generic,
kind: crate::error::CreateResourceGroupErrorKind::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::CreateResourceGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceTemporarilyUnavailableException" => crate::error::CreateResourceGroupError {
meta: generic,
kind:
crate::error::CreateResourceGroupErrorKind::ServiceTemporarilyUnavailableException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::service_temporarily_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_temporarily_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateResourceGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
_ => crate::error::CreateResourceGroupError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_resource_group_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateResourceGroupOutput,
crate::error::CreateResourceGroupError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_resource_group_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_resource_group(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateResourceGroupError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_assessment_run_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteAssessmentRunOutput,
crate::error::DeleteAssessmentRunError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteAssessmentRunError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteAssessmentRunError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::DeleteAssessmentRunError {
meta: generic,
kind: crate::error::DeleteAssessmentRunErrorKind::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::DeleteAssessmentRunError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"AssessmentRunInProgressException" => crate::error::DeleteAssessmentRunError {
meta: generic,
kind: crate::error::DeleteAssessmentRunErrorKind::AssessmentRunInProgressException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::assessment_run_in_progress_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_assessment_run_in_progress_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteAssessmentRunError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalException" => {
crate::error::DeleteAssessmentRunError {
meta: generic,
kind: crate::error::DeleteAssessmentRunErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteAssessmentRunError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidInputException" => crate::error::DeleteAssessmentRunError {
meta: generic,
kind: crate::error::DeleteAssessmentRunErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteAssessmentRunError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NoSuchEntityException" => crate::error::DeleteAssessmentRunError {
meta: generic,
kind: crate::error::DeleteAssessmentRunErrorKind::NoSuchEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::no_such_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_no_such_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteAssessmentRunError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceTemporarilyUnavailableException" => crate::error::DeleteAssessmentRunError {
meta: generic,
kind:
crate::error::DeleteAssessmentRunErrorKind::ServiceTemporarilyUnavailableException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::service_temporarily_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_temporarily_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteAssessmentRunError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
_ => crate::error::DeleteAssessmentRunError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_assessment_run_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteAssessmentRunOutput,
crate::error::DeleteAssessmentRunError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_assessment_run_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_assessment_target_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteAssessmentTargetOutput,
crate::error::DeleteAssessmentTargetError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteAssessmentTargetError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DeleteAssessmentTargetError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::DeleteAssessmentTargetError { meta: generic, kind: crate::error::DeleteAssessmentTargetErrorKind::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::DeleteAssessmentTargetError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"AssessmentRunInProgressException" => crate::error::DeleteAssessmentTargetError { meta: generic, kind: crate::error::DeleteAssessmentTargetErrorKind::AssessmentRunInProgressException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::assessment_run_in_progress_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_assessment_run_in_progress_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteAssessmentTargetError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"InternalException" => crate::error::DeleteAssessmentTargetError { meta: generic, kind: crate::error::DeleteAssessmentTargetErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteAssessmentTargetError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"InvalidInputException" => crate::error::DeleteAssessmentTargetError { meta: generic, kind: crate::error::DeleteAssessmentTargetErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteAssessmentTargetError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"NoSuchEntityException" => crate::error::DeleteAssessmentTargetError { meta: generic, kind: crate::error::DeleteAssessmentTargetErrorKind::NoSuchEntityException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::no_such_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_no_such_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteAssessmentTargetError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ServiceTemporarilyUnavailableException" => crate::error::DeleteAssessmentTargetError { meta: generic, kind: crate::error::DeleteAssessmentTargetErrorKind::ServiceTemporarilyUnavailableException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::service_temporarily_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_temporarily_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteAssessmentTargetError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
_ => crate::error::DeleteAssessmentTargetError::generic(generic)
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_assessment_target_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteAssessmentTargetOutput,
crate::error::DeleteAssessmentTargetError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_assessment_target_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_assessment_template_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteAssessmentTemplateOutput,
crate::error::DeleteAssessmentTemplateError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteAssessmentTemplateError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DeleteAssessmentTemplateError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::DeleteAssessmentTemplateError { meta: generic, kind: crate::error::DeleteAssessmentTemplateErrorKind::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::DeleteAssessmentTemplateError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"AssessmentRunInProgressException" => crate::error::DeleteAssessmentTemplateError { meta: generic, kind: crate::error::DeleteAssessmentTemplateErrorKind::AssessmentRunInProgressException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::assessment_run_in_progress_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_assessment_run_in_progress_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteAssessmentTemplateError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"InternalException" => crate::error::DeleteAssessmentTemplateError { meta: generic, kind: crate::error::DeleteAssessmentTemplateErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteAssessmentTemplateError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"InvalidInputException" => crate::error::DeleteAssessmentTemplateError { meta: generic, kind: crate::error::DeleteAssessmentTemplateErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteAssessmentTemplateError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"NoSuchEntityException" => crate::error::DeleteAssessmentTemplateError { meta: generic, kind: crate::error::DeleteAssessmentTemplateErrorKind::NoSuchEntityException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::no_such_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_no_such_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteAssessmentTemplateError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ServiceTemporarilyUnavailableException" => crate::error::DeleteAssessmentTemplateError { meta: generic, kind: crate::error::DeleteAssessmentTemplateErrorKind::ServiceTemporarilyUnavailableException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::service_temporarily_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_temporarily_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteAssessmentTemplateError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
_ => crate::error::DeleteAssessmentTemplateError::generic(generic)
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_assessment_template_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteAssessmentTemplateOutput,
crate::error::DeleteAssessmentTemplateError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_assessment_template_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_assessment_runs_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeAssessmentRunsOutput,
crate::error::DescribeAssessmentRunsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeAssessmentRunsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeAssessmentRunsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalException" => {
crate::error::DescribeAssessmentRunsError {
meta: generic,
kind: crate::error::DescribeAssessmentRunsErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeAssessmentRunsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidInputException" => crate::error::DescribeAssessmentRunsError {
meta: generic,
kind: crate::error::DescribeAssessmentRunsErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeAssessmentRunsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeAssessmentRunsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_assessment_runs_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeAssessmentRunsOutput,
crate::error::DescribeAssessmentRunsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_assessment_runs_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_assessment_runs(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeAssessmentRunsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_assessment_targets_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeAssessmentTargetsOutput,
crate::error::DescribeAssessmentTargetsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeAssessmentTargetsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeAssessmentTargetsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalException" => {
crate::error::DescribeAssessmentTargetsError {
meta: generic,
kind: crate::error::DescribeAssessmentTargetsErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeAssessmentTargetsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidInputException" => crate::error::DescribeAssessmentTargetsError {
meta: generic,
kind: crate::error::DescribeAssessmentTargetsErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeAssessmentTargetsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeAssessmentTargetsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_assessment_targets_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeAssessmentTargetsOutput,
crate::error::DescribeAssessmentTargetsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_assessment_targets_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_assessment_targets(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeAssessmentTargetsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_assessment_templates_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeAssessmentTemplatesOutput,
crate::error::DescribeAssessmentTemplatesError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeAssessmentTemplatesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeAssessmentTemplatesError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalException" => {
crate::error::DescribeAssessmentTemplatesError {
meta: generic,
kind: crate::error::DescribeAssessmentTemplatesErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeAssessmentTemplatesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidInputException" => crate::error::DescribeAssessmentTemplatesError {
meta: generic,
kind: crate::error::DescribeAssessmentTemplatesErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeAssessmentTemplatesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeAssessmentTemplatesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_assessment_templates_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeAssessmentTemplatesOutput,
crate::error::DescribeAssessmentTemplatesError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_assessment_templates_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_assessment_templates(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeAssessmentTemplatesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_cross_account_access_role_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeCrossAccountAccessRoleOutput,
crate::error::DescribeCrossAccountAccessRoleError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeCrossAccountAccessRoleError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeCrossAccountAccessRoleError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalException" => {
crate::error::DescribeCrossAccountAccessRoleError {
meta: generic,
kind: crate::error::DescribeCrossAccountAccessRoleErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeCrossAccountAccessRoleError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
_ => crate::error::DescribeCrossAccountAccessRoleError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_cross_account_access_role_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeCrossAccountAccessRoleOutput,
crate::error::DescribeCrossAccountAccessRoleError,
> {
Ok({
#[allow(unused_mut)]
let mut output =
crate::output::describe_cross_account_access_role_output::Builder::default();
let _ = response;
output =
crate::json_deser::deser_operation_crate_operation_describe_cross_account_access_role(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeCrossAccountAccessRoleError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_exclusions_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeExclusionsOutput,
crate::error::DescribeExclusionsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeExclusionsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeExclusionsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalException" => {
crate::error::DescribeExclusionsError {
meta: generic,
kind: crate::error::DescribeExclusionsErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeExclusionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidInputException" => crate::error::DescribeExclusionsError {
meta: generic,
kind: crate::error::DescribeExclusionsErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeExclusionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeExclusionsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_exclusions_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeExclusionsOutput,
crate::error::DescribeExclusionsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_exclusions_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_exclusions(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeExclusionsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_findings_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeFindingsOutput, crate::error::DescribeFindingsError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeFindingsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeFindingsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalException" => {
crate::error::DescribeFindingsError {
meta: generic,
kind: crate::error::DescribeFindingsErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeFindingsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidInputException" => crate::error::DescribeFindingsError {
meta: generic,
kind: crate::error::DescribeFindingsErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeFindingsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeFindingsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_findings_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeFindingsOutput, crate::error::DescribeFindingsError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_findings_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_findings(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeFindingsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_resource_groups_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeResourceGroupsOutput,
crate::error::DescribeResourceGroupsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeResourceGroupsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeResourceGroupsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalException" => {
crate::error::DescribeResourceGroupsError {
meta: generic,
kind: crate::error::DescribeResourceGroupsErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeResourceGroupsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidInputException" => crate::error::DescribeResourceGroupsError {
meta: generic,
kind: crate::error::DescribeResourceGroupsErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeResourceGroupsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeResourceGroupsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_resource_groups_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeResourceGroupsOutput,
crate::error::DescribeResourceGroupsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_resource_groups_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_resource_groups(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeResourceGroupsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_rules_packages_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeRulesPackagesOutput,
crate::error::DescribeRulesPackagesError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeRulesPackagesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeRulesPackagesError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalException" => {
crate::error::DescribeRulesPackagesError {
meta: generic,
kind: crate::error::DescribeRulesPackagesErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeRulesPackagesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidInputException" => crate::error::DescribeRulesPackagesError {
meta: generic,
kind: crate::error::DescribeRulesPackagesErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeRulesPackagesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeRulesPackagesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_rules_packages_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeRulesPackagesOutput,
crate::error::DescribeRulesPackagesError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_rules_packages_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_rules_packages(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeRulesPackagesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_assessment_report_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetAssessmentReportOutput,
crate::error::GetAssessmentReportError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetAssessmentReportError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::GetAssessmentReportError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::GetAssessmentReportError {
meta: generic,
kind: crate::error::GetAssessmentReportErrorKind::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::GetAssessmentReportError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"AssessmentRunInProgressException" => crate::error::GetAssessmentReportError {
meta: generic,
kind: crate::error::GetAssessmentReportErrorKind::AssessmentRunInProgressException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::assessment_run_in_progress_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_assessment_run_in_progress_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetAssessmentReportError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalException" => {
crate::error::GetAssessmentReportError {
meta: generic,
kind: crate::error::GetAssessmentReportErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetAssessmentReportError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidInputException" => crate::error::GetAssessmentReportError {
meta: generic,
kind: crate::error::GetAssessmentReportErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetAssessmentReportError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NoSuchEntityException" => crate::error::GetAssessmentReportError {
meta: generic,
kind: crate::error::GetAssessmentReportErrorKind::NoSuchEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::no_such_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_no_such_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetAssessmentReportError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceTemporarilyUnavailableException" => crate::error::GetAssessmentReportError {
meta: generic,
kind:
crate::error::GetAssessmentReportErrorKind::ServiceTemporarilyUnavailableException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::service_temporarily_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_temporarily_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetAssessmentReportError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"UnsupportedFeatureException" => crate::error::GetAssessmentReportError {
meta: generic,
kind: crate::error::GetAssessmentReportErrorKind::UnsupportedFeatureException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::unsupported_feature_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_unsupported_feature_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetAssessmentReportError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetAssessmentReportError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_assessment_report_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetAssessmentReportOutput,
crate::error::GetAssessmentReportError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_assessment_report_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_assessment_report(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetAssessmentReportError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_exclusions_preview_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetExclusionsPreviewOutput,
crate::error::GetExclusionsPreviewError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetExclusionsPreviewError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::GetExclusionsPreviewError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::GetExclusionsPreviewError {
meta: generic,
kind: crate::error::GetExclusionsPreviewErrorKind::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::GetExclusionsPreviewError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalException" => {
crate::error::GetExclusionsPreviewError {
meta: generic,
kind: crate::error::GetExclusionsPreviewErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetExclusionsPreviewError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidInputException" => crate::error::GetExclusionsPreviewError {
meta: generic,
kind: crate::error::GetExclusionsPreviewErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetExclusionsPreviewError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NoSuchEntityException" => crate::error::GetExclusionsPreviewError {
meta: generic,
kind: crate::error::GetExclusionsPreviewErrorKind::NoSuchEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::no_such_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_no_such_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetExclusionsPreviewError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetExclusionsPreviewError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_exclusions_preview_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetExclusionsPreviewOutput,
crate::error::GetExclusionsPreviewError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_exclusions_preview_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_exclusions_preview(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetExclusionsPreviewError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_telemetry_metadata_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetTelemetryMetadataOutput,
crate::error::GetTelemetryMetadataError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetTelemetryMetadataError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::GetTelemetryMetadataError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::GetTelemetryMetadataError {
meta: generic,
kind: crate::error::GetTelemetryMetadataErrorKind::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::GetTelemetryMetadataError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalException" => {
crate::error::GetTelemetryMetadataError {
meta: generic,
kind: crate::error::GetTelemetryMetadataErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetTelemetryMetadataError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidInputException" => crate::error::GetTelemetryMetadataError {
meta: generic,
kind: crate::error::GetTelemetryMetadataErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetTelemetryMetadataError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NoSuchEntityException" => crate::error::GetTelemetryMetadataError {
meta: generic,
kind: crate::error::GetTelemetryMetadataErrorKind::NoSuchEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::no_such_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_no_such_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetTelemetryMetadataError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetTelemetryMetadataError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_telemetry_metadata_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetTelemetryMetadataOutput,
crate::error::GetTelemetryMetadataError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_telemetry_metadata_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_telemetry_metadata(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetTelemetryMetadataError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_assessment_run_agents_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListAssessmentRunAgentsOutput,
crate::error::ListAssessmentRunAgentsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListAssessmentRunAgentsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListAssessmentRunAgentsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ListAssessmentRunAgentsError {
meta: generic,
kind: crate::error::ListAssessmentRunAgentsErrorKind::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::ListAssessmentRunAgentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalException" => {
crate::error::ListAssessmentRunAgentsError {
meta: generic,
kind: crate::error::ListAssessmentRunAgentsErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAssessmentRunAgentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidInputException" => crate::error::ListAssessmentRunAgentsError {
meta: generic,
kind: crate::error::ListAssessmentRunAgentsErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAssessmentRunAgentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NoSuchEntityException" => crate::error::ListAssessmentRunAgentsError {
meta: generic,
kind: crate::error::ListAssessmentRunAgentsErrorKind::NoSuchEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::no_such_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_no_such_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAssessmentRunAgentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListAssessmentRunAgentsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_assessment_run_agents_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListAssessmentRunAgentsOutput,
crate::error::ListAssessmentRunAgentsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_assessment_run_agents_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_assessment_run_agents(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListAssessmentRunAgentsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_assessment_runs_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListAssessmentRunsOutput,
crate::error::ListAssessmentRunsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListAssessmentRunsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListAssessmentRunsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ListAssessmentRunsError {
meta: generic,
kind: crate::error::ListAssessmentRunsErrorKind::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::ListAssessmentRunsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalException" => {
crate::error::ListAssessmentRunsError {
meta: generic,
kind: crate::error::ListAssessmentRunsErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAssessmentRunsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidInputException" => crate::error::ListAssessmentRunsError {
meta: generic,
kind: crate::error::ListAssessmentRunsErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAssessmentRunsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NoSuchEntityException" => crate::error::ListAssessmentRunsError {
meta: generic,
kind: crate::error::ListAssessmentRunsErrorKind::NoSuchEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::no_such_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_no_such_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAssessmentRunsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListAssessmentRunsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_assessment_runs_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListAssessmentRunsOutput,
crate::error::ListAssessmentRunsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_assessment_runs_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_assessment_runs(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListAssessmentRunsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_assessment_targets_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListAssessmentTargetsOutput,
crate::error::ListAssessmentTargetsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListAssessmentTargetsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListAssessmentTargetsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ListAssessmentTargetsError {
meta: generic,
kind: crate::error::ListAssessmentTargetsErrorKind::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::ListAssessmentTargetsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalException" => {
crate::error::ListAssessmentTargetsError {
meta: generic,
kind: crate::error::ListAssessmentTargetsErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAssessmentTargetsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidInputException" => crate::error::ListAssessmentTargetsError {
meta: generic,
kind: crate::error::ListAssessmentTargetsErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAssessmentTargetsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListAssessmentTargetsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_assessment_targets_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListAssessmentTargetsOutput,
crate::error::ListAssessmentTargetsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_assessment_targets_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_assessment_targets(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListAssessmentTargetsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_assessment_templates_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListAssessmentTemplatesOutput,
crate::error::ListAssessmentTemplatesError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListAssessmentTemplatesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListAssessmentTemplatesError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ListAssessmentTemplatesError {
meta: generic,
kind: crate::error::ListAssessmentTemplatesErrorKind::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::ListAssessmentTemplatesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalException" => {
crate::error::ListAssessmentTemplatesError {
meta: generic,
kind: crate::error::ListAssessmentTemplatesErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAssessmentTemplatesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidInputException" => crate::error::ListAssessmentTemplatesError {
meta: generic,
kind: crate::error::ListAssessmentTemplatesErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAssessmentTemplatesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NoSuchEntityException" => crate::error::ListAssessmentTemplatesError {
meta: generic,
kind: crate::error::ListAssessmentTemplatesErrorKind::NoSuchEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::no_such_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_no_such_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAssessmentTemplatesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListAssessmentTemplatesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_assessment_templates_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListAssessmentTemplatesOutput,
crate::error::ListAssessmentTemplatesError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_assessment_templates_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_assessment_templates(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListAssessmentTemplatesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_event_subscriptions_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListEventSubscriptionsOutput,
crate::error::ListEventSubscriptionsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListEventSubscriptionsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListEventSubscriptionsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ListEventSubscriptionsError {
meta: generic,
kind: crate::error::ListEventSubscriptionsErrorKind::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::ListEventSubscriptionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalException" => {
crate::error::ListEventSubscriptionsError {
meta: generic,
kind: crate::error::ListEventSubscriptionsErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListEventSubscriptionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidInputException" => crate::error::ListEventSubscriptionsError {
meta: generic,
kind: crate::error::ListEventSubscriptionsErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListEventSubscriptionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NoSuchEntityException" => crate::error::ListEventSubscriptionsError {
meta: generic,
kind: crate::error::ListEventSubscriptionsErrorKind::NoSuchEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::no_such_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_no_such_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListEventSubscriptionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListEventSubscriptionsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_event_subscriptions_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListEventSubscriptionsOutput,
crate::error::ListEventSubscriptionsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_event_subscriptions_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_event_subscriptions(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListEventSubscriptionsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_exclusions_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListExclusionsOutput, crate::error::ListExclusionsError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListExclusionsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListExclusionsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ListExclusionsError {
meta: generic,
kind: crate::error::ListExclusionsErrorKind::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::ListExclusionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalException" => {
crate::error::ListExclusionsError {
meta: generic,
kind: crate::error::ListExclusionsErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListExclusionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidInputException" => crate::error::ListExclusionsError {
meta: generic,
kind: crate::error::ListExclusionsErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListExclusionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NoSuchEntityException" => crate::error::ListExclusionsError {
meta: generic,
kind: crate::error::ListExclusionsErrorKind::NoSuchEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::no_such_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_no_such_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListExclusionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListExclusionsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_exclusions_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListExclusionsOutput, crate::error::ListExclusionsError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_exclusions_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_exclusions(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListExclusionsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_findings_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListFindingsOutput, crate::error::ListFindingsError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListFindingsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListFindingsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ListFindingsError {
meta: generic,
kind: crate::error::ListFindingsErrorKind::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::ListFindingsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalException" => {
crate::error::ListFindingsError {
meta: generic,
kind: crate::error::ListFindingsErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListFindingsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidInputException" => crate::error::ListFindingsError {
meta: generic,
kind: crate::error::ListFindingsErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListFindingsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NoSuchEntityException" => crate::error::ListFindingsError {
meta: generic,
kind: crate::error::ListFindingsErrorKind::NoSuchEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::no_such_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_no_such_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListFindingsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListFindingsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_findings_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListFindingsOutput, crate::error::ListFindingsError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_findings_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_findings(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListFindingsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_rules_packages_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListRulesPackagesOutput, crate::error::ListRulesPackagesError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListRulesPackagesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListRulesPackagesError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ListRulesPackagesError {
meta: generic,
kind: crate::error::ListRulesPackagesErrorKind::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::ListRulesPackagesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalException" => {
crate::error::ListRulesPackagesError {
meta: generic,
kind: crate::error::ListRulesPackagesErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListRulesPackagesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidInputException" => crate::error::ListRulesPackagesError {
meta: generic,
kind: crate::error::ListRulesPackagesErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListRulesPackagesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListRulesPackagesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_rules_packages_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListRulesPackagesOutput, crate::error::ListRulesPackagesError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_rules_packages_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_rules_packages(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListRulesPackagesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_tags_for_resource_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListTagsForResourceOutput,
crate::error::ListTagsForResourceError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListTagsForResourceError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListTagsForResourceError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ListTagsForResourceError {
meta: generic,
kind: crate::error::ListTagsForResourceErrorKind::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::ListTagsForResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalException" => {
crate::error::ListTagsForResourceError {
meta: generic,
kind: crate::error::ListTagsForResourceErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTagsForResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidInputException" => crate::error::ListTagsForResourceError {
meta: generic,
kind: crate::error::ListTagsForResourceErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTagsForResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NoSuchEntityException" => crate::error::ListTagsForResourceError {
meta: generic,
kind: crate::error::ListTagsForResourceErrorKind::NoSuchEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::no_such_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_no_such_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTagsForResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListTagsForResourceError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_tags_for_resource_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListTagsForResourceOutput,
crate::error::ListTagsForResourceError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_tags_for_resource_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_tags_for_resource(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListTagsForResourceError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_preview_agents_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::PreviewAgentsOutput, crate::error::PreviewAgentsError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::PreviewAgentsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::PreviewAgentsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::PreviewAgentsError {
meta: generic,
kind: crate::error::PreviewAgentsErrorKind::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::PreviewAgentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalException" => {
crate::error::PreviewAgentsError {
meta: generic,
kind: crate::error::PreviewAgentsErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PreviewAgentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidCrossAccountRoleException" => crate::error::PreviewAgentsError {
meta: generic,
kind: crate::error::PreviewAgentsErrorKind::InvalidCrossAccountRoleException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_cross_account_role_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_cross_account_role_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PreviewAgentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidInputException" => crate::error::PreviewAgentsError {
meta: generic,
kind: crate::error::PreviewAgentsErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PreviewAgentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NoSuchEntityException" => crate::error::PreviewAgentsError {
meta: generic,
kind: crate::error::PreviewAgentsErrorKind::NoSuchEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::no_such_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_no_such_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PreviewAgentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::PreviewAgentsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_preview_agents_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::PreviewAgentsOutput, crate::error::PreviewAgentsError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::preview_agents_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_preview_agents(
response.body().as_ref(),
output,
)
.map_err(crate::error::PreviewAgentsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_register_cross_account_access_role_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::RegisterCrossAccountAccessRoleOutput,
crate::error::RegisterCrossAccountAccessRoleError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::RegisterCrossAccountAccessRoleError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::RegisterCrossAccountAccessRoleError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::RegisterCrossAccountAccessRoleError { meta: generic, kind: crate::error::RegisterCrossAccountAccessRoleErrorKind::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::RegisterCrossAccountAccessRoleError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"InternalException" => crate::error::RegisterCrossAccountAccessRoleError { meta: generic, kind: crate::error::RegisterCrossAccountAccessRoleErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RegisterCrossAccountAccessRoleError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"InvalidCrossAccountRoleException" => crate::error::RegisterCrossAccountAccessRoleError { meta: generic, kind: crate::error::RegisterCrossAccountAccessRoleErrorKind::InvalidCrossAccountRoleException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::invalid_cross_account_role_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_cross_account_role_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RegisterCrossAccountAccessRoleError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"InvalidInputException" => crate::error::RegisterCrossAccountAccessRoleError { meta: generic, kind: crate::error::RegisterCrossAccountAccessRoleErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RegisterCrossAccountAccessRoleError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ServiceTemporarilyUnavailableException" => crate::error::RegisterCrossAccountAccessRoleError { meta: generic, kind: crate::error::RegisterCrossAccountAccessRoleErrorKind::ServiceTemporarilyUnavailableException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::service_temporarily_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_temporarily_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RegisterCrossAccountAccessRoleError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
_ => crate::error::RegisterCrossAccountAccessRoleError::generic(generic)
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_register_cross_account_access_role_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::RegisterCrossAccountAccessRoleOutput,
crate::error::RegisterCrossAccountAccessRoleError,
> {
Ok({
#[allow(unused_mut)]
let mut output =
crate::output::register_cross_account_access_role_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_remove_attributes_from_findings_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::RemoveAttributesFromFindingsOutput,
crate::error::RemoveAttributesFromFindingsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::RemoveAttributesFromFindingsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::RemoveAttributesFromFindingsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::RemoveAttributesFromFindingsError { meta: generic, kind: crate::error::RemoveAttributesFromFindingsErrorKind::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::RemoveAttributesFromFindingsError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"InternalException" => crate::error::RemoveAttributesFromFindingsError { meta: generic, kind: crate::error::RemoveAttributesFromFindingsErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RemoveAttributesFromFindingsError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"InvalidInputException" => crate::error::RemoveAttributesFromFindingsError { meta: generic, kind: crate::error::RemoveAttributesFromFindingsErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RemoveAttributesFromFindingsError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"NoSuchEntityException" => crate::error::RemoveAttributesFromFindingsError { meta: generic, kind: crate::error::RemoveAttributesFromFindingsErrorKind::NoSuchEntityException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::no_such_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_no_such_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RemoveAttributesFromFindingsError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ServiceTemporarilyUnavailableException" => crate::error::RemoveAttributesFromFindingsError { meta: generic, kind: crate::error::RemoveAttributesFromFindingsErrorKind::ServiceTemporarilyUnavailableException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::service_temporarily_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_temporarily_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RemoveAttributesFromFindingsError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
_ => crate::error::RemoveAttributesFromFindingsError::generic(generic)
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_remove_attributes_from_findings_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::RemoveAttributesFromFindingsOutput,
crate::error::RemoveAttributesFromFindingsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::remove_attributes_from_findings_output::Builder::default();
let _ = response;
output =
crate::json_deser::deser_operation_crate_operation_remove_attributes_from_findings(
response.body().as_ref(),
output,
)
.map_err(crate::error::RemoveAttributesFromFindingsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_set_tags_for_resource_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::SetTagsForResourceOutput,
crate::error::SetTagsForResourceError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::SetTagsForResourceError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::SetTagsForResourceError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::SetTagsForResourceError {
meta: generic,
kind: crate::error::SetTagsForResourceErrorKind::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::SetTagsForResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalException" => {
crate::error::SetTagsForResourceError {
meta: generic,
kind: crate::error::SetTagsForResourceErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::SetTagsForResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidInputException" => crate::error::SetTagsForResourceError {
meta: generic,
kind: crate::error::SetTagsForResourceErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::SetTagsForResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NoSuchEntityException" => crate::error::SetTagsForResourceError {
meta: generic,
kind: crate::error::SetTagsForResourceErrorKind::NoSuchEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::no_such_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_no_such_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::SetTagsForResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceTemporarilyUnavailableException" => crate::error::SetTagsForResourceError {
meta: generic,
kind: crate::error::SetTagsForResourceErrorKind::ServiceTemporarilyUnavailableException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::service_temporarily_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_temporarily_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::SetTagsForResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
_ => crate::error::SetTagsForResourceError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_set_tags_for_resource_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::SetTagsForResourceOutput,
crate::error::SetTagsForResourceError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::set_tags_for_resource_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_assessment_run_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::StartAssessmentRunOutput,
crate::error::StartAssessmentRunError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StartAssessmentRunError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::StartAssessmentRunError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::StartAssessmentRunError {
meta: generic,
kind: crate::error::StartAssessmentRunErrorKind::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::StartAssessmentRunError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"AgentsAlreadyRunningAssessmentException" => crate::error::StartAssessmentRunError {
meta: generic,
kind:
crate::error::StartAssessmentRunErrorKind::AgentsAlreadyRunningAssessmentException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::agents_already_running_assessment_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_agents_already_running_assessment_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartAssessmentRunError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"InternalException" => {
crate::error::StartAssessmentRunError {
meta: generic,
kind: crate::error::StartAssessmentRunErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartAssessmentRunError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidCrossAccountRoleException" => crate::error::StartAssessmentRunError {
meta: generic,
kind: crate::error::StartAssessmentRunErrorKind::InvalidCrossAccountRoleException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_cross_account_role_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_cross_account_role_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartAssessmentRunError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidInputException" => crate::error::StartAssessmentRunError {
meta: generic,
kind: crate::error::StartAssessmentRunErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartAssessmentRunError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::StartAssessmentRunError {
meta: generic,
kind: crate::error::StartAssessmentRunErrorKind::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::StartAssessmentRunError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NoSuchEntityException" => crate::error::StartAssessmentRunError {
meta: generic,
kind: crate::error::StartAssessmentRunErrorKind::NoSuchEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::no_such_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_no_such_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartAssessmentRunError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceTemporarilyUnavailableException" => crate::error::StartAssessmentRunError {
meta: generic,
kind: crate::error::StartAssessmentRunErrorKind::ServiceTemporarilyUnavailableException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::service_temporarily_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_temporarily_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartAssessmentRunError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
_ => crate::error::StartAssessmentRunError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_assessment_run_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::StartAssessmentRunOutput,
crate::error::StartAssessmentRunError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::start_assessment_run_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_start_assessment_run(
response.body().as_ref(),
output,
)
.map_err(crate::error::StartAssessmentRunError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_assessment_run_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StopAssessmentRunOutput, crate::error::StopAssessmentRunError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StopAssessmentRunError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::StopAssessmentRunError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::StopAssessmentRunError {
meta: generic,
kind: crate::error::StopAssessmentRunErrorKind::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::StopAssessmentRunError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalException" => {
crate::error::StopAssessmentRunError {
meta: generic,
kind: crate::error::StopAssessmentRunErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopAssessmentRunError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidInputException" => crate::error::StopAssessmentRunError {
meta: generic,
kind: crate::error::StopAssessmentRunErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopAssessmentRunError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NoSuchEntityException" => crate::error::StopAssessmentRunError {
meta: generic,
kind: crate::error::StopAssessmentRunErrorKind::NoSuchEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::no_such_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_no_such_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopAssessmentRunError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceTemporarilyUnavailableException" => crate::error::StopAssessmentRunError {
meta: generic,
kind: crate::error::StopAssessmentRunErrorKind::ServiceTemporarilyUnavailableException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::service_temporarily_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_temporarily_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopAssessmentRunError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
_ => crate::error::StopAssessmentRunError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_assessment_run_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StopAssessmentRunOutput, crate::error::StopAssessmentRunError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::stop_assessment_run_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_subscribe_to_event_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::SubscribeToEventOutput, crate::error::SubscribeToEventError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::SubscribeToEventError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::SubscribeToEventError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::SubscribeToEventError {
meta: generic,
kind: crate::error::SubscribeToEventErrorKind::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::SubscribeToEventError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalException" => {
crate::error::SubscribeToEventError {
meta: generic,
kind: crate::error::SubscribeToEventErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::SubscribeToEventError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidInputException" => crate::error::SubscribeToEventError {
meta: generic,
kind: crate::error::SubscribeToEventErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::SubscribeToEventError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::SubscribeToEventError {
meta: generic,
kind: crate::error::SubscribeToEventErrorKind::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::SubscribeToEventError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NoSuchEntityException" => crate::error::SubscribeToEventError {
meta: generic,
kind: crate::error::SubscribeToEventErrorKind::NoSuchEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::no_such_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_no_such_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::SubscribeToEventError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceTemporarilyUnavailableException" => crate::error::SubscribeToEventError {
meta: generic,
kind: crate::error::SubscribeToEventErrorKind::ServiceTemporarilyUnavailableException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::service_temporarily_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_temporarily_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::SubscribeToEventError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
_ => crate::error::SubscribeToEventError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_subscribe_to_event_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::SubscribeToEventOutput, crate::error::SubscribeToEventError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::subscribe_to_event_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_unsubscribe_from_event_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UnsubscribeFromEventOutput,
crate::error::UnsubscribeFromEventError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UnsubscribeFromEventError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UnsubscribeFromEventError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::UnsubscribeFromEventError {
meta: generic,
kind: crate::error::UnsubscribeFromEventErrorKind::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::UnsubscribeFromEventError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalException" => {
crate::error::UnsubscribeFromEventError {
meta: generic,
kind: crate::error::UnsubscribeFromEventErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UnsubscribeFromEventError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidInputException" => crate::error::UnsubscribeFromEventError {
meta: generic,
kind: crate::error::UnsubscribeFromEventErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UnsubscribeFromEventError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NoSuchEntityException" => crate::error::UnsubscribeFromEventError {
meta: generic,
kind: crate::error::UnsubscribeFromEventErrorKind::NoSuchEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::no_such_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_no_such_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UnsubscribeFromEventError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceTemporarilyUnavailableException" => crate::error::UnsubscribeFromEventError {
meta: generic,
kind:
crate::error::UnsubscribeFromEventErrorKind::ServiceTemporarilyUnavailableException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::service_temporarily_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_temporarily_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UnsubscribeFromEventError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
_ => crate::error::UnsubscribeFromEventError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_unsubscribe_from_event_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UnsubscribeFromEventOutput,
crate::error::UnsubscribeFromEventError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::unsubscribe_from_event_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_assessment_target_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateAssessmentTargetOutput,
crate::error::UpdateAssessmentTargetError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateAssessmentTargetError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::UpdateAssessmentTargetError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::UpdateAssessmentTargetError { meta: generic, kind: crate::error::UpdateAssessmentTargetErrorKind::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::UpdateAssessmentTargetError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"InternalException" => crate::error::UpdateAssessmentTargetError { meta: generic, kind: crate::error::UpdateAssessmentTargetErrorKind::InternalException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::internal_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateAssessmentTargetError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"InvalidInputException" => crate::error::UpdateAssessmentTargetError { meta: generic, kind: crate::error::UpdateAssessmentTargetErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateAssessmentTargetError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"NoSuchEntityException" => crate::error::UpdateAssessmentTargetError { meta: generic, kind: crate::error::UpdateAssessmentTargetErrorKind::NoSuchEntityException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::no_such_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_no_such_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateAssessmentTargetError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ServiceTemporarilyUnavailableException" => crate::error::UpdateAssessmentTargetError { meta: generic, kind: crate::error::UpdateAssessmentTargetErrorKind::ServiceTemporarilyUnavailableException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::service_temporarily_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_temporarily_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateAssessmentTargetError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
_ => crate::error::UpdateAssessmentTargetError::generic(generic)
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_assessment_target_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateAssessmentTargetOutput,
crate::error::UpdateAssessmentTargetError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_assessment_target_output::Builder::default();
let _ = response;
output.build()
})
}