#[allow(clippy::unnecessary_wraps)]
pub fn parse_add_facet_to_object_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::AddFacetToObjectOutput, crate::error::AddFacetToObjectError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::AddFacetToObjectError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::AddFacetToObjectError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::AddFacetToObjectError {
meta: generic,
kind: crate::error::AddFacetToObjectErrorKind::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::AddFacetToObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::AddFacetToObjectError {
meta: generic,
kind: crate::error::AddFacetToObjectErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AddFacetToObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetValidationException" => crate::error::AddFacetToObjectError {
meta: generic,
kind: crate::error::AddFacetToObjectErrorKind::FacetValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::facet_validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AddFacetToObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::AddFacetToObjectError {
meta: generic,
kind: crate::error::AddFacetToObjectErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AddFacetToObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::AddFacetToObjectError {
meta: generic,
kind: crate::error::AddFacetToObjectErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AddFacetToObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::AddFacetToObjectError {
meta: generic,
kind: crate::error::AddFacetToObjectErrorKind::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::AddFacetToObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::AddFacetToObjectError {
meta: generic,
kind: crate::error::AddFacetToObjectErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AddFacetToObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::AddFacetToObjectError {
meta: generic,
kind: crate::error::AddFacetToObjectErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AddFacetToObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::AddFacetToObjectError {
meta: generic,
kind: crate::error::AddFacetToObjectErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AddFacetToObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::AddFacetToObjectError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_add_facet_to_object_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::AddFacetToObjectOutput, crate::error::AddFacetToObjectError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::add_facet_to_object_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_apply_schema_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ApplySchemaOutput, crate::error::ApplySchemaError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ApplySchemaError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ApplySchemaError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ApplySchemaError {
meta: generic,
kind: crate::error::ApplySchemaErrorKind::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::ApplySchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::ApplySchemaError {
meta: generic,
kind: crate::error::ApplySchemaErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ApplySchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::ApplySchemaError {
meta: generic,
kind: crate::error::ApplySchemaErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ApplySchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidAttachmentException" => crate::error::ApplySchemaError {
meta: generic,
kind: crate::error::ApplySchemaErrorKind::InvalidAttachmentException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_attachment_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_attachment_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ApplySchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::ApplySchemaError {
meta: generic,
kind: crate::error::ApplySchemaErrorKind::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::ApplySchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ApplySchemaError {
meta: generic,
kind: crate::error::ApplySchemaErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ApplySchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::ApplySchemaError {
meta: generic,
kind: crate::error::ApplySchemaErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ApplySchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"SchemaAlreadyExistsException" => crate::error::ApplySchemaError {
meta: generic,
kind: crate::error::ApplySchemaErrorKind::SchemaAlreadyExistsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::schema_already_exists_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_schema_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ApplySchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::ApplySchemaError {
meta: generic,
kind: crate::error::ApplySchemaErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ApplySchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ApplySchemaError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_apply_schema_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ApplySchemaOutput, crate::error::ApplySchemaError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::apply_schema_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_apply_schema(
response.body().as_ref(),
output,
)
.map_err(crate::error::ApplySchemaError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_attach_object_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::AttachObjectOutput, crate::error::AttachObjectError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::AttachObjectError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::AttachObjectError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::AttachObjectError {
meta: generic,
kind: crate::error::AttachObjectErrorKind::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::AttachObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::AttachObjectError {
meta: generic,
kind: crate::error::AttachObjectErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetValidationException" => crate::error::AttachObjectError {
meta: generic,
kind: crate::error::AttachObjectErrorKind::FacetValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::facet_validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::AttachObjectError {
meta: generic,
kind: crate::error::AttachObjectErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::AttachObjectError {
meta: generic,
kind: crate::error::AttachObjectErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidAttachmentException" => crate::error::AttachObjectError {
meta: generic,
kind: crate::error::AttachObjectErrorKind::InvalidAttachmentException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_attachment_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_attachment_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::AttachObjectError {
meta: generic,
kind: crate::error::AttachObjectErrorKind::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::AttachObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LinkNameAlreadyInUseException" => crate::error::AttachObjectError {
meta: generic,
kind: crate::error::AttachObjectErrorKind::LinkNameAlreadyInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::link_name_already_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_link_name_already_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::AttachObjectError {
meta: generic,
kind: crate::error::AttachObjectErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::AttachObjectError {
meta: generic,
kind: crate::error::AttachObjectErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::AttachObjectError {
meta: generic,
kind: crate::error::AttachObjectErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::AttachObjectError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_attach_object_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::AttachObjectOutput, crate::error::AttachObjectError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::attach_object_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_attach_object(
response.body().as_ref(),
output,
)
.map_err(crate::error::AttachObjectError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_attach_policy_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::AttachPolicyOutput, crate::error::AttachPolicyError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::AttachPolicyError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::AttachPolicyError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::AttachPolicyError {
meta: generic,
kind: crate::error::AttachPolicyErrorKind::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::AttachPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::AttachPolicyError {
meta: generic,
kind: crate::error::AttachPolicyErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::AttachPolicyError {
meta: generic,
kind: crate::error::AttachPolicyErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::AttachPolicyError {
meta: generic,
kind: crate::error::AttachPolicyErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::AttachPolicyError {
meta: generic,
kind: crate::error::AttachPolicyErrorKind::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::AttachPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotPolicyException" => crate::error::AttachPolicyError {
meta: generic,
kind: crate::error::AttachPolicyErrorKind::NotPolicyException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_policy_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_policy_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::AttachPolicyError {
meta: generic,
kind: crate::error::AttachPolicyErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::AttachPolicyError {
meta: generic,
kind: crate::error::AttachPolicyErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::AttachPolicyError {
meta: generic,
kind: crate::error::AttachPolicyErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::AttachPolicyError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_attach_policy_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::AttachPolicyOutput, crate::error::AttachPolicyError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::attach_policy_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_attach_to_index_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::AttachToIndexOutput, crate::error::AttachToIndexError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::AttachToIndexError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::AttachToIndexError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::AttachToIndexError {
meta: generic,
kind: crate::error::AttachToIndexErrorKind::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::AttachToIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::AttachToIndexError {
meta: generic,
kind: crate::error::AttachToIndexErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachToIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"IndexedAttributeMissingException" => crate::error::AttachToIndexError {
meta: generic,
kind: crate::error::AttachToIndexErrorKind::IndexedAttributeMissingException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::indexed_attribute_missing_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_indexed_attribute_missing_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachToIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::AttachToIndexError {
meta: generic,
kind: crate::error::AttachToIndexErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachToIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::AttachToIndexError {
meta: generic,
kind: crate::error::AttachToIndexErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachToIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidAttachmentException" => crate::error::AttachToIndexError {
meta: generic,
kind: crate::error::AttachToIndexErrorKind::InvalidAttachmentException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_attachment_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_attachment_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachToIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::AttachToIndexError {
meta: generic,
kind: crate::error::AttachToIndexErrorKind::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::AttachToIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LinkNameAlreadyInUseException" => crate::error::AttachToIndexError {
meta: generic,
kind: crate::error::AttachToIndexErrorKind::LinkNameAlreadyInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::link_name_already_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_link_name_already_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachToIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotIndexException" => crate::error::AttachToIndexError {
meta: generic,
kind: crate::error::AttachToIndexErrorKind::NotIndexException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_index_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_index_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachToIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::AttachToIndexError {
meta: generic,
kind: crate::error::AttachToIndexErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachToIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::AttachToIndexError {
meta: generic,
kind: crate::error::AttachToIndexErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachToIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::AttachToIndexError {
meta: generic,
kind: crate::error::AttachToIndexErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachToIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::AttachToIndexError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_attach_to_index_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::AttachToIndexOutput, crate::error::AttachToIndexError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::attach_to_index_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_attach_to_index(
response.body().as_ref(),
output,
)
.map_err(crate::error::AttachToIndexError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_attach_typed_link_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::AttachTypedLinkOutput, crate::error::AttachTypedLinkError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::AttachTypedLinkError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::AttachTypedLinkError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::AttachTypedLinkError {
meta: generic,
kind: crate::error::AttachTypedLinkErrorKind::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::AttachTypedLinkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::AttachTypedLinkError {
meta: generic,
kind: crate::error::AttachTypedLinkErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachTypedLinkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetValidationException" => crate::error::AttachTypedLinkError {
meta: generic,
kind: crate::error::AttachTypedLinkErrorKind::FacetValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::facet_validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachTypedLinkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::AttachTypedLinkError {
meta: generic,
kind: crate::error::AttachTypedLinkErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachTypedLinkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::AttachTypedLinkError {
meta: generic,
kind: crate::error::AttachTypedLinkErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachTypedLinkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidAttachmentException" => crate::error::AttachTypedLinkError {
meta: generic,
kind: crate::error::AttachTypedLinkErrorKind::InvalidAttachmentException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_attachment_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_attachment_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachTypedLinkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::AttachTypedLinkError {
meta: generic,
kind: crate::error::AttachTypedLinkErrorKind::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::AttachTypedLinkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::AttachTypedLinkError {
meta: generic,
kind: crate::error::AttachTypedLinkErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachTypedLinkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::AttachTypedLinkError {
meta: generic,
kind: crate::error::AttachTypedLinkErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachTypedLinkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::AttachTypedLinkError {
meta: generic,
kind: crate::error::AttachTypedLinkErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AttachTypedLinkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::AttachTypedLinkError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_attach_typed_link_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::AttachTypedLinkOutput, crate::error::AttachTypedLinkError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::attach_typed_link_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_attach_typed_link(
response.body().as_ref(),
output,
)
.map_err(crate::error::AttachTypedLinkError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_batch_read_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::BatchReadOutput, crate::error::BatchReadError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::BatchReadError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::BatchReadError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::BatchReadError {
meta: generic,
kind: crate::error::BatchReadErrorKind::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::BatchReadError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::BatchReadError {
meta: generic,
kind: crate::error::BatchReadErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchReadError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::BatchReadError {
meta: generic,
kind: crate::error::BatchReadErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchReadError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::BatchReadError {
meta: generic,
kind: crate::error::BatchReadErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchReadError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::BatchReadError {
meta: generic,
kind: crate::error::BatchReadErrorKind::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::BatchReadError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::BatchReadError {
meta: generic,
kind: crate::error::BatchReadErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchReadError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::BatchReadError {
meta: generic,
kind: crate::error::BatchReadErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchReadError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::BatchReadError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_batch_read_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::BatchReadOutput, crate::error::BatchReadError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::batch_read_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_batch_read(
response.body().as_ref(),
output,
)
.map_err(crate::error::BatchReadError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_batch_write_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::BatchWriteOutput, crate::error::BatchWriteError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::BatchWriteError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::BatchWriteError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::BatchWriteError {
meta: generic,
kind: crate::error::BatchWriteErrorKind::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::BatchWriteError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BatchWriteException" => crate::error::BatchWriteError {
meta: generic,
kind: crate::error::BatchWriteErrorKind::BatchWriteException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::batch_write_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_batch_write_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchWriteError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::BatchWriteError {
meta: generic,
kind: crate::error::BatchWriteErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchWriteError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::BatchWriteError {
meta: generic,
kind: crate::error::BatchWriteErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchWriteError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::BatchWriteError {
meta: generic,
kind: crate::error::BatchWriteErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchWriteError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::BatchWriteError {
meta: generic,
kind: crate::error::BatchWriteErrorKind::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::BatchWriteError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::BatchWriteError {
meta: generic,
kind: crate::error::BatchWriteErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchWriteError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::BatchWriteError {
meta: generic,
kind: crate::error::BatchWriteErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchWriteError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::BatchWriteError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_batch_write_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::BatchWriteOutput, crate::error::BatchWriteError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::batch_write_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_batch_write(
response.body().as_ref(),
output,
)
.map_err(crate::error::BatchWriteError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_directory_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateDirectoryOutput, crate::error::CreateDirectoryError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateDirectoryError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateDirectoryError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::CreateDirectoryError {
meta: generic,
kind: crate::error::CreateDirectoryErrorKind::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::CreateDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryAlreadyExistsException" => crate::error::CreateDirectoryError {
meta: generic,
kind: crate::error::CreateDirectoryErrorKind::DirectoryAlreadyExistsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_already_exists_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::CreateDirectoryError {
meta: generic,
kind: crate::error::CreateDirectoryErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::CreateDirectoryError {
meta: generic,
kind: crate::error::CreateDirectoryErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateDirectoryError {
meta: generic,
kind: crate::error::CreateDirectoryErrorKind::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::CreateDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateDirectoryError {
meta: generic,
kind: crate::error::CreateDirectoryErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::CreateDirectoryError {
meta: generic,
kind: crate::error::CreateDirectoryErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::CreateDirectoryError {
meta: generic,
kind: crate::error::CreateDirectoryErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateDirectoryError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_directory_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateDirectoryOutput, crate::error::CreateDirectoryError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_directory_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_directory(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateDirectoryError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_facet_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateFacetOutput, crate::error::CreateFacetError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateFacetError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateFacetError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::CreateFacetError {
meta: generic,
kind: crate::error::CreateFacetErrorKind::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::CreateFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetAlreadyExistsException" => crate::error::CreateFacetError {
meta: generic,
kind: crate::error::CreateFacetErrorKind::FacetAlreadyExistsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::facet_already_exists_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetValidationException" => crate::error::CreateFacetError {
meta: generic,
kind: crate::error::CreateFacetErrorKind::FacetValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::facet_validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::CreateFacetError {
meta: generic,
kind: crate::error::CreateFacetErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::CreateFacetError {
meta: generic,
kind: crate::error::CreateFacetErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRuleException" => crate::error::CreateFacetError {
meta: generic,
kind: crate::error::CreateFacetErrorKind::InvalidRuleException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_rule_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_rule_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateFacetError {
meta: generic,
kind: crate::error::CreateFacetErrorKind::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::CreateFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateFacetError {
meta: generic,
kind: crate::error::CreateFacetErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::CreateFacetError {
meta: generic,
kind: crate::error::CreateFacetErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::CreateFacetError {
meta: generic,
kind: crate::error::CreateFacetErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateFacetError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_facet_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateFacetOutput, crate::error::CreateFacetError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_facet_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_index_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateIndexOutput, crate::error::CreateIndexError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateIndexError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateIndexError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::CreateIndexError {
meta: generic,
kind: crate::error::CreateIndexErrorKind::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::CreateIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::CreateIndexError {
meta: generic,
kind: crate::error::CreateIndexErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetValidationException" => crate::error::CreateIndexError {
meta: generic,
kind: crate::error::CreateIndexErrorKind::FacetValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::facet_validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::CreateIndexError {
meta: generic,
kind: crate::error::CreateIndexErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::CreateIndexError {
meta: generic,
kind: crate::error::CreateIndexErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateIndexError {
meta: generic,
kind: crate::error::CreateIndexErrorKind::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::CreateIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LinkNameAlreadyInUseException" => crate::error::CreateIndexError {
meta: generic,
kind: crate::error::CreateIndexErrorKind::LinkNameAlreadyInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::link_name_already_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_link_name_already_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateIndexError {
meta: generic,
kind: crate::error::CreateIndexErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::CreateIndexError {
meta: generic,
kind: crate::error::CreateIndexErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"UnsupportedIndexTypeException" => crate::error::CreateIndexError {
meta: generic,
kind: crate::error::CreateIndexErrorKind::UnsupportedIndexTypeException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::unsupported_index_type_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_unsupported_index_type_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::CreateIndexError {
meta: generic,
kind: crate::error::CreateIndexErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateIndexError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_index_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateIndexOutput, crate::error::CreateIndexError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_index_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_index(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateIndexError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_object_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateObjectOutput, crate::error::CreateObjectError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateObjectError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateObjectError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::CreateObjectError {
meta: generic,
kind: crate::error::CreateObjectErrorKind::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::CreateObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::CreateObjectError {
meta: generic,
kind: crate::error::CreateObjectErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetValidationException" => crate::error::CreateObjectError {
meta: generic,
kind: crate::error::CreateObjectErrorKind::FacetValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::facet_validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::CreateObjectError {
meta: generic,
kind: crate::error::CreateObjectErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::CreateObjectError {
meta: generic,
kind: crate::error::CreateObjectErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateObjectError {
meta: generic,
kind: crate::error::CreateObjectErrorKind::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::CreateObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LinkNameAlreadyInUseException" => crate::error::CreateObjectError {
meta: generic,
kind: crate::error::CreateObjectErrorKind::LinkNameAlreadyInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::link_name_already_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_link_name_already_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateObjectError {
meta: generic,
kind: crate::error::CreateObjectErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::CreateObjectError {
meta: generic,
kind: crate::error::CreateObjectErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"UnsupportedIndexTypeException" => crate::error::CreateObjectError {
meta: generic,
kind: crate::error::CreateObjectErrorKind::UnsupportedIndexTypeException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::unsupported_index_type_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_unsupported_index_type_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::CreateObjectError {
meta: generic,
kind: crate::error::CreateObjectErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateObjectError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_object_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateObjectOutput, crate::error::CreateObjectError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_object_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_object(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateObjectError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_schema_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateSchemaOutput, crate::error::CreateSchemaError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateSchemaError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateSchemaError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::CreateSchemaError {
meta: generic,
kind: crate::error::CreateSchemaErrorKind::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::CreateSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::CreateSchemaError {
meta: generic,
kind: crate::error::CreateSchemaErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::CreateSchemaError {
meta: generic,
kind: crate::error::CreateSchemaErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateSchemaError {
meta: generic,
kind: crate::error::CreateSchemaErrorKind::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::CreateSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::CreateSchemaError {
meta: generic,
kind: crate::error::CreateSchemaErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"SchemaAlreadyExistsException" => crate::error::CreateSchemaError {
meta: generic,
kind: crate::error::CreateSchemaErrorKind::SchemaAlreadyExistsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::schema_already_exists_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_schema_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::CreateSchemaError {
meta: generic,
kind: crate::error::CreateSchemaErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateSchemaError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_schema_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateSchemaOutput, crate::error::CreateSchemaError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_schema_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_schema(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateSchemaError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_typed_link_facet_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateTypedLinkFacetOutput,
crate::error::CreateTypedLinkFacetError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateTypedLinkFacetError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateTypedLinkFacetError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::CreateTypedLinkFacetError {
meta: generic,
kind: crate::error::CreateTypedLinkFacetErrorKind::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::CreateTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetAlreadyExistsException" => crate::error::CreateTypedLinkFacetError {
meta: generic,
kind: crate::error::CreateTypedLinkFacetErrorKind::FacetAlreadyExistsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::facet_already_exists_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetValidationException" => crate::error::CreateTypedLinkFacetError {
meta: generic,
kind: crate::error::CreateTypedLinkFacetErrorKind::FacetValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::facet_validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::CreateTypedLinkFacetError {
meta: generic,
kind: crate::error::CreateTypedLinkFacetErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::CreateTypedLinkFacetError {
meta: generic,
kind: crate::error::CreateTypedLinkFacetErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRuleException" => crate::error::CreateTypedLinkFacetError {
meta: generic,
kind: crate::error::CreateTypedLinkFacetErrorKind::InvalidRuleException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_rule_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_rule_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateTypedLinkFacetError {
meta: generic,
kind: crate::error::CreateTypedLinkFacetErrorKind::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::CreateTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateTypedLinkFacetError {
meta: generic,
kind: crate::error::CreateTypedLinkFacetErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::CreateTypedLinkFacetError {
meta: generic,
kind: crate::error::CreateTypedLinkFacetErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::CreateTypedLinkFacetError {
meta: generic,
kind: crate::error::CreateTypedLinkFacetErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateTypedLinkFacetError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_typed_link_facet_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateTypedLinkFacetOutput,
crate::error::CreateTypedLinkFacetError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_typed_link_facet_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_directory_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteDirectoryOutput, crate::error::DeleteDirectoryError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteDirectoryError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteDirectoryError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::DeleteDirectoryError {
meta: generic,
kind: crate::error::DeleteDirectoryErrorKind::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::DeleteDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryDeletedException" => crate::error::DeleteDirectoryError {
meta: generic,
kind: crate::error::DeleteDirectoryErrorKind::DirectoryDeletedException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::directory_deleted_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_deleted_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotDisabledException" => crate::error::DeleteDirectoryError {
meta: generic,
kind: crate::error::DeleteDirectoryErrorKind::DirectoryNotDisabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_disabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_disabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::DeleteDirectoryError {
meta: generic,
kind: crate::error::DeleteDirectoryErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::DeleteDirectoryError {
meta: generic,
kind: crate::error::DeleteDirectoryErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::DeleteDirectoryError {
meta: generic,
kind: crate::error::DeleteDirectoryErrorKind::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::DeleteDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteDirectoryError {
meta: generic,
kind: crate::error::DeleteDirectoryErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::DeleteDirectoryError {
meta: generic,
kind: crate::error::DeleteDirectoryErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::DeleteDirectoryError {
meta: generic,
kind: crate::error::DeleteDirectoryErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteDirectoryError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_directory_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteDirectoryOutput, crate::error::DeleteDirectoryError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_directory_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_delete_directory(
response.body().as_ref(),
output,
)
.map_err(crate::error::DeleteDirectoryError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_facet_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteFacetOutput, crate::error::DeleteFacetError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteFacetError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteFacetError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::DeleteFacetError {
meta: generic,
kind: crate::error::DeleteFacetErrorKind::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::DeleteFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetInUseException" => crate::error::DeleteFacetError {
meta: generic,
kind: crate::error::DeleteFacetErrorKind::FacetInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::facet_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetNotFoundException" => crate::error::DeleteFacetError {
meta: generic,
kind: crate::error::DeleteFacetErrorKind::FacetNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::facet_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::DeleteFacetError {
meta: generic,
kind: crate::error::DeleteFacetErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::DeleteFacetError {
meta: generic,
kind: crate::error::DeleteFacetErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::DeleteFacetError {
meta: generic,
kind: crate::error::DeleteFacetErrorKind::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::DeleteFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteFacetError {
meta: generic,
kind: crate::error::DeleteFacetErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::DeleteFacetError {
meta: generic,
kind: crate::error::DeleteFacetErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::DeleteFacetError {
meta: generic,
kind: crate::error::DeleteFacetErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteFacetError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_facet_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteFacetOutput, crate::error::DeleteFacetError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_facet_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_object_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteObjectOutput, crate::error::DeleteObjectError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteObjectError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteObjectError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::DeleteObjectError {
meta: generic,
kind: crate::error::DeleteObjectErrorKind::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::DeleteObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::DeleteObjectError {
meta: generic,
kind: crate::error::DeleteObjectErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::DeleteObjectError {
meta: generic,
kind: crate::error::DeleteObjectErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::DeleteObjectError {
meta: generic,
kind: crate::error::DeleteObjectErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::DeleteObjectError {
meta: generic,
kind: crate::error::DeleteObjectErrorKind::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::DeleteObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ObjectNotDetachedException" => crate::error::DeleteObjectError {
meta: generic,
kind: crate::error::DeleteObjectErrorKind::ObjectNotDetachedException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::object_not_detached_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_object_not_detached_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteObjectError {
meta: generic,
kind: crate::error::DeleteObjectErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::DeleteObjectError {
meta: generic,
kind: crate::error::DeleteObjectErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::DeleteObjectError {
meta: generic,
kind: crate::error::DeleteObjectErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteObjectError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_object_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteObjectOutput, crate::error::DeleteObjectError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_object_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_schema_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteSchemaOutput, crate::error::DeleteSchemaError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteSchemaError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteSchemaError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::DeleteSchemaError {
meta: generic,
kind: crate::error::DeleteSchemaErrorKind::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::DeleteSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::DeleteSchemaError {
meta: generic,
kind: crate::error::DeleteSchemaErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::DeleteSchemaError {
meta: generic,
kind: crate::error::DeleteSchemaErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::DeleteSchemaError {
meta: generic,
kind: crate::error::DeleteSchemaErrorKind::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::DeleteSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteSchemaError {
meta: generic,
kind: crate::error::DeleteSchemaErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::DeleteSchemaError {
meta: generic,
kind: crate::error::DeleteSchemaErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"StillContainsLinksException" => crate::error::DeleteSchemaError {
meta: generic,
kind: crate::error::DeleteSchemaErrorKind::StillContainsLinksException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::still_contains_links_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_still_contains_links_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::DeleteSchemaError {
meta: generic,
kind: crate::error::DeleteSchemaErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteSchemaError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_schema_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteSchemaOutput, crate::error::DeleteSchemaError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_schema_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_delete_schema(
response.body().as_ref(),
output,
)
.map_err(crate::error::DeleteSchemaError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_typed_link_facet_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteTypedLinkFacetOutput,
crate::error::DeleteTypedLinkFacetError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteTypedLinkFacetError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteTypedLinkFacetError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::DeleteTypedLinkFacetError {
meta: generic,
kind: crate::error::DeleteTypedLinkFacetErrorKind::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::DeleteTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetNotFoundException" => crate::error::DeleteTypedLinkFacetError {
meta: generic,
kind: crate::error::DeleteTypedLinkFacetErrorKind::FacetNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::facet_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::DeleteTypedLinkFacetError {
meta: generic,
kind: crate::error::DeleteTypedLinkFacetErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::DeleteTypedLinkFacetError {
meta: generic,
kind: crate::error::DeleteTypedLinkFacetErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::DeleteTypedLinkFacetError {
meta: generic,
kind: crate::error::DeleteTypedLinkFacetErrorKind::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::DeleteTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteTypedLinkFacetError {
meta: generic,
kind: crate::error::DeleteTypedLinkFacetErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::DeleteTypedLinkFacetError {
meta: generic,
kind: crate::error::DeleteTypedLinkFacetErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::DeleteTypedLinkFacetError {
meta: generic,
kind: crate::error::DeleteTypedLinkFacetErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteTypedLinkFacetError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_typed_link_facet_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteTypedLinkFacetOutput,
crate::error::DeleteTypedLinkFacetError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_typed_link_facet_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_detach_from_index_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DetachFromIndexOutput, crate::error::DetachFromIndexError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DetachFromIndexError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DetachFromIndexError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::DetachFromIndexError {
meta: generic,
kind: crate::error::DetachFromIndexErrorKind::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::DetachFromIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::DetachFromIndexError {
meta: generic,
kind: crate::error::DetachFromIndexErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachFromIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::DetachFromIndexError {
meta: generic,
kind: crate::error::DetachFromIndexErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachFromIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::DetachFromIndexError {
meta: generic,
kind: crate::error::DetachFromIndexErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachFromIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::DetachFromIndexError {
meta: generic,
kind: crate::error::DetachFromIndexErrorKind::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::DetachFromIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotIndexException" => crate::error::DetachFromIndexError {
meta: generic,
kind: crate::error::DetachFromIndexErrorKind::NotIndexException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_index_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_index_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachFromIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ObjectAlreadyDetachedException" => crate::error::DetachFromIndexError {
meta: generic,
kind: crate::error::DetachFromIndexErrorKind::ObjectAlreadyDetachedException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::object_already_detached_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_object_already_detached_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachFromIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DetachFromIndexError {
meta: generic,
kind: crate::error::DetachFromIndexErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachFromIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::DetachFromIndexError {
meta: generic,
kind: crate::error::DetachFromIndexErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachFromIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::DetachFromIndexError {
meta: generic,
kind: crate::error::DetachFromIndexErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachFromIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DetachFromIndexError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_detach_from_index_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DetachFromIndexOutput, crate::error::DetachFromIndexError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::detach_from_index_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_detach_from_index(
response.body().as_ref(),
output,
)
.map_err(crate::error::DetachFromIndexError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_detach_object_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DetachObjectOutput, crate::error::DetachObjectError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DetachObjectError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DetachObjectError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::DetachObjectError {
meta: generic,
kind: crate::error::DetachObjectErrorKind::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::DetachObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::DetachObjectError {
meta: generic,
kind: crate::error::DetachObjectErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::DetachObjectError {
meta: generic,
kind: crate::error::DetachObjectErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::DetachObjectError {
meta: generic,
kind: crate::error::DetachObjectErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::DetachObjectError {
meta: generic,
kind: crate::error::DetachObjectErrorKind::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::DetachObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotNodeException" => {
crate::error::DetachObjectError {
meta: generic,
kind: crate::error::DetachObjectErrorKind::NotNodeException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_node_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_node_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ResourceNotFoundException" => crate::error::DetachObjectError {
meta: generic,
kind: crate::error::DetachObjectErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::DetachObjectError {
meta: generic,
kind: crate::error::DetachObjectErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::DetachObjectError {
meta: generic,
kind: crate::error::DetachObjectErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DetachObjectError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_detach_object_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DetachObjectOutput, crate::error::DetachObjectError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::detach_object_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_detach_object(
response.body().as_ref(),
output,
)
.map_err(crate::error::DetachObjectError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_detach_policy_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DetachPolicyOutput, crate::error::DetachPolicyError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DetachPolicyError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DetachPolicyError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::DetachPolicyError {
meta: generic,
kind: crate::error::DetachPolicyErrorKind::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::DetachPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::DetachPolicyError {
meta: generic,
kind: crate::error::DetachPolicyErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::DetachPolicyError {
meta: generic,
kind: crate::error::DetachPolicyErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::DetachPolicyError {
meta: generic,
kind: crate::error::DetachPolicyErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::DetachPolicyError {
meta: generic,
kind: crate::error::DetachPolicyErrorKind::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::DetachPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotPolicyException" => crate::error::DetachPolicyError {
meta: generic,
kind: crate::error::DetachPolicyErrorKind::NotPolicyException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_policy_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_policy_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DetachPolicyError {
meta: generic,
kind: crate::error::DetachPolicyErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::DetachPolicyError {
meta: generic,
kind: crate::error::DetachPolicyErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::DetachPolicyError {
meta: generic,
kind: crate::error::DetachPolicyErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DetachPolicyError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_detach_policy_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DetachPolicyOutput, crate::error::DetachPolicyError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::detach_policy_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_detach_typed_link_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DetachTypedLinkOutput, crate::error::DetachTypedLinkError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DetachTypedLinkError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DetachTypedLinkError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::DetachTypedLinkError {
meta: generic,
kind: crate::error::DetachTypedLinkErrorKind::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::DetachTypedLinkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::DetachTypedLinkError {
meta: generic,
kind: crate::error::DetachTypedLinkErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachTypedLinkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetValidationException" => crate::error::DetachTypedLinkError {
meta: generic,
kind: crate::error::DetachTypedLinkErrorKind::FacetValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::facet_validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachTypedLinkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::DetachTypedLinkError {
meta: generic,
kind: crate::error::DetachTypedLinkErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachTypedLinkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::DetachTypedLinkError {
meta: generic,
kind: crate::error::DetachTypedLinkErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachTypedLinkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::DetachTypedLinkError {
meta: generic,
kind: crate::error::DetachTypedLinkErrorKind::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::DetachTypedLinkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DetachTypedLinkError {
meta: generic,
kind: crate::error::DetachTypedLinkErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachTypedLinkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::DetachTypedLinkError {
meta: generic,
kind: crate::error::DetachTypedLinkErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachTypedLinkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::DetachTypedLinkError {
meta: generic,
kind: crate::error::DetachTypedLinkErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetachTypedLinkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DetachTypedLinkError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_detach_typed_link_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DetachTypedLinkOutput, crate::error::DetachTypedLinkError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::detach_typed_link_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_disable_directory_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DisableDirectoryOutput, crate::error::DisableDirectoryError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DisableDirectoryError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DisableDirectoryError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::DisableDirectoryError {
meta: generic,
kind: crate::error::DisableDirectoryErrorKind::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::DisableDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryDeletedException" => crate::error::DisableDirectoryError {
meta: generic,
kind: crate::error::DisableDirectoryErrorKind::DirectoryDeletedException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::directory_deleted_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_deleted_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DisableDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::DisableDirectoryError {
meta: generic,
kind: crate::error::DisableDirectoryErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DisableDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::DisableDirectoryError {
meta: generic,
kind: crate::error::DisableDirectoryErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DisableDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::DisableDirectoryError {
meta: generic,
kind: crate::error::DisableDirectoryErrorKind::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::DisableDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DisableDirectoryError {
meta: generic,
kind: crate::error::DisableDirectoryErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DisableDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::DisableDirectoryError {
meta: generic,
kind: crate::error::DisableDirectoryErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DisableDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::DisableDirectoryError {
meta: generic,
kind: crate::error::DisableDirectoryErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DisableDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DisableDirectoryError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_disable_directory_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DisableDirectoryOutput, crate::error::DisableDirectoryError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::disable_directory_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_disable_directory(
response.body().as_ref(),
output,
)
.map_err(crate::error::DisableDirectoryError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_enable_directory_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::EnableDirectoryOutput, crate::error::EnableDirectoryError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::EnableDirectoryError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::EnableDirectoryError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::EnableDirectoryError {
meta: generic,
kind: crate::error::EnableDirectoryErrorKind::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::EnableDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryDeletedException" => crate::error::EnableDirectoryError {
meta: generic,
kind: crate::error::EnableDirectoryErrorKind::DirectoryDeletedException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::directory_deleted_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_deleted_exception_json_err(response.body().as_ref(), output).map_err(crate::error::EnableDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::EnableDirectoryError {
meta: generic,
kind: crate::error::EnableDirectoryErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::EnableDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::EnableDirectoryError {
meta: generic,
kind: crate::error::EnableDirectoryErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::EnableDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::EnableDirectoryError {
meta: generic,
kind: crate::error::EnableDirectoryErrorKind::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::EnableDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::EnableDirectoryError {
meta: generic,
kind: crate::error::EnableDirectoryErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::EnableDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::EnableDirectoryError {
meta: generic,
kind: crate::error::EnableDirectoryErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::EnableDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::EnableDirectoryError {
meta: generic,
kind: crate::error::EnableDirectoryErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::EnableDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::EnableDirectoryError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_enable_directory_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::EnableDirectoryOutput, crate::error::EnableDirectoryError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::enable_directory_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_enable_directory(
response.body().as_ref(),
output,
)
.map_err(crate::error::EnableDirectoryError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_applied_schema_version_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetAppliedSchemaVersionOutput,
crate::error::GetAppliedSchemaVersionError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetAppliedSchemaVersionError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::GetAppliedSchemaVersionError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::GetAppliedSchemaVersionError {
meta: generic,
kind: crate::error::GetAppliedSchemaVersionErrorKind::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::GetAppliedSchemaVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::GetAppliedSchemaVersionError {
meta: generic,
kind: crate::error::GetAppliedSchemaVersionErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetAppliedSchemaVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::GetAppliedSchemaVersionError {
meta: generic,
kind: crate::error::GetAppliedSchemaVersionErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetAppliedSchemaVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::GetAppliedSchemaVersionError {
meta: generic,
kind: crate::error::GetAppliedSchemaVersionErrorKind::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::GetAppliedSchemaVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::GetAppliedSchemaVersionError {
meta: generic,
kind: crate::error::GetAppliedSchemaVersionErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetAppliedSchemaVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::GetAppliedSchemaVersionError {
meta: generic,
kind: crate::error::GetAppliedSchemaVersionErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetAppliedSchemaVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::GetAppliedSchemaVersionError {
meta: generic,
kind: crate::error::GetAppliedSchemaVersionErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetAppliedSchemaVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetAppliedSchemaVersionError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_applied_schema_version_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetAppliedSchemaVersionOutput,
crate::error::GetAppliedSchemaVersionError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_applied_schema_version_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_applied_schema_version(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetAppliedSchemaVersionError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_directory_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetDirectoryOutput, crate::error::GetDirectoryError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetDirectoryError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::GetDirectoryError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::GetDirectoryError {
meta: generic,
kind: crate::error::GetDirectoryErrorKind::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::GetDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::GetDirectoryError {
meta: generic,
kind: crate::error::GetDirectoryErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::GetDirectoryError {
meta: generic,
kind: crate::error::GetDirectoryErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::GetDirectoryError {
meta: generic,
kind: crate::error::GetDirectoryErrorKind::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::GetDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::GetDirectoryError {
meta: generic,
kind: crate::error::GetDirectoryErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::GetDirectoryError {
meta: generic,
kind: crate::error::GetDirectoryErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDirectoryError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetDirectoryError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_directory_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetDirectoryOutput, crate::error::GetDirectoryError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_directory_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_directory(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetDirectoryError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_facet_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetFacetOutput, crate::error::GetFacetError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetFacetError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::GetFacetError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::GetFacetError {
meta: generic,
kind: crate::error::GetFacetErrorKind::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::GetFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetNotFoundException" => crate::error::GetFacetError {
meta: generic,
kind: crate::error::GetFacetErrorKind::FacetNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::facet_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::GetFacetError {
meta: generic,
kind: crate::error::GetFacetErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::GetFacetError {
meta: generic,
kind: crate::error::GetFacetErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::GetFacetError {
meta: generic,
kind: crate::error::GetFacetErrorKind::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::GetFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::GetFacetError {
meta: generic,
kind: crate::error::GetFacetErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::GetFacetError {
meta: generic,
kind: crate::error::GetFacetErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::GetFacetError {
meta: generic,
kind: crate::error::GetFacetErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetFacetError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_facet_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetFacetOutput, crate::error::GetFacetError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_facet_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_facet(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetFacetError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_link_attributes_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetLinkAttributesOutput, crate::error::GetLinkAttributesError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetLinkAttributesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::GetLinkAttributesError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::GetLinkAttributesError {
meta: generic,
kind: crate::error::GetLinkAttributesErrorKind::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::GetLinkAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::GetLinkAttributesError {
meta: generic,
kind: crate::error::GetLinkAttributesErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetLinkAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetValidationException" => crate::error::GetLinkAttributesError {
meta: generic,
kind: crate::error::GetLinkAttributesErrorKind::FacetValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::facet_validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetLinkAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::GetLinkAttributesError {
meta: generic,
kind: crate::error::GetLinkAttributesErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetLinkAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::GetLinkAttributesError {
meta: generic,
kind: crate::error::GetLinkAttributesErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetLinkAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::GetLinkAttributesError {
meta: generic,
kind: crate::error::GetLinkAttributesErrorKind::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::GetLinkAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::GetLinkAttributesError {
meta: generic,
kind: crate::error::GetLinkAttributesErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetLinkAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::GetLinkAttributesError {
meta: generic,
kind: crate::error::GetLinkAttributesErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetLinkAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::GetLinkAttributesError {
meta: generic,
kind: crate::error::GetLinkAttributesErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetLinkAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetLinkAttributesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_link_attributes_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetLinkAttributesOutput, crate::error::GetLinkAttributesError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_link_attributes_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_link_attributes(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetLinkAttributesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_object_attributes_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetObjectAttributesOutput,
crate::error::GetObjectAttributesError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetObjectAttributesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::GetObjectAttributesError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::GetObjectAttributesError {
meta: generic,
kind: crate::error::GetObjectAttributesErrorKind::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::GetObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::GetObjectAttributesError {
meta: generic,
kind: crate::error::GetObjectAttributesErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetValidationException" => crate::error::GetObjectAttributesError {
meta: generic,
kind: crate::error::GetObjectAttributesErrorKind::FacetValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::facet_validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::GetObjectAttributesError {
meta: generic,
kind: crate::error::GetObjectAttributesErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::GetObjectAttributesError {
meta: generic,
kind: crate::error::GetObjectAttributesErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::GetObjectAttributesError {
meta: generic,
kind: crate::error::GetObjectAttributesErrorKind::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::GetObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::GetObjectAttributesError {
meta: generic,
kind: crate::error::GetObjectAttributesErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::GetObjectAttributesError {
meta: generic,
kind: crate::error::GetObjectAttributesErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::GetObjectAttributesError {
meta: generic,
kind: crate::error::GetObjectAttributesErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetObjectAttributesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_object_attributes_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetObjectAttributesOutput,
crate::error::GetObjectAttributesError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_object_attributes_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_object_attributes(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetObjectAttributesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_object_information_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetObjectInformationOutput,
crate::error::GetObjectInformationError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetObjectInformationError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::GetObjectInformationError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::GetObjectInformationError {
meta: generic,
kind: crate::error::GetObjectInformationErrorKind::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::GetObjectInformationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::GetObjectInformationError {
meta: generic,
kind: crate::error::GetObjectInformationErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetObjectInformationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::GetObjectInformationError {
meta: generic,
kind: crate::error::GetObjectInformationErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetObjectInformationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::GetObjectInformationError {
meta: generic,
kind: crate::error::GetObjectInformationErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetObjectInformationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::GetObjectInformationError {
meta: generic,
kind: crate::error::GetObjectInformationErrorKind::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::GetObjectInformationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::GetObjectInformationError {
meta: generic,
kind: crate::error::GetObjectInformationErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetObjectInformationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::GetObjectInformationError {
meta: generic,
kind: crate::error::GetObjectInformationErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetObjectInformationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::GetObjectInformationError {
meta: generic,
kind: crate::error::GetObjectInformationErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetObjectInformationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetObjectInformationError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_object_information_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetObjectInformationOutput,
crate::error::GetObjectInformationError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_object_information_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_object_information(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetObjectInformationError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_schema_as_json_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetSchemaAsJsonOutput, crate::error::GetSchemaAsJsonError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetSchemaAsJsonError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::GetSchemaAsJsonError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::GetSchemaAsJsonError {
meta: generic,
kind: crate::error::GetSchemaAsJsonErrorKind::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::GetSchemaAsJsonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::GetSchemaAsJsonError {
meta: generic,
kind: crate::error::GetSchemaAsJsonErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetSchemaAsJsonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::GetSchemaAsJsonError {
meta: generic,
kind: crate::error::GetSchemaAsJsonErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetSchemaAsJsonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::GetSchemaAsJsonError {
meta: generic,
kind: crate::error::GetSchemaAsJsonErrorKind::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::GetSchemaAsJsonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::GetSchemaAsJsonError {
meta: generic,
kind: crate::error::GetSchemaAsJsonErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetSchemaAsJsonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::GetSchemaAsJsonError {
meta: generic,
kind: crate::error::GetSchemaAsJsonErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetSchemaAsJsonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::GetSchemaAsJsonError {
meta: generic,
kind: crate::error::GetSchemaAsJsonErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetSchemaAsJsonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetSchemaAsJsonError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_schema_as_json_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetSchemaAsJsonOutput, crate::error::GetSchemaAsJsonError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_schema_as_json_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_schema_as_json(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetSchemaAsJsonError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_typed_link_facet_information_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetTypedLinkFacetInformationOutput,
crate::error::GetTypedLinkFacetInformationError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetTypedLinkFacetInformationError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::GetTypedLinkFacetInformationError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::GetTypedLinkFacetInformationError {
meta: generic,
kind: crate::error::GetTypedLinkFacetInformationErrorKind::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::GetTypedLinkFacetInformationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetNotFoundException" => crate::error::GetTypedLinkFacetInformationError {
meta: generic,
kind: crate::error::GetTypedLinkFacetInformationErrorKind::FacetNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::facet_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetTypedLinkFacetInformationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::GetTypedLinkFacetInformationError {
meta: generic,
kind: crate::error::GetTypedLinkFacetInformationErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetTypedLinkFacetInformationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::GetTypedLinkFacetInformationError {
meta: generic,
kind: crate::error::GetTypedLinkFacetInformationErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetTypedLinkFacetInformationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::GetTypedLinkFacetInformationError {
meta: generic,
kind: crate::error::GetTypedLinkFacetInformationErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetTypedLinkFacetInformationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::GetTypedLinkFacetInformationError {
meta: generic,
kind: crate::error::GetTypedLinkFacetInformationErrorKind::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::GetTypedLinkFacetInformationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::GetTypedLinkFacetInformationError {
meta: generic,
kind: crate::error::GetTypedLinkFacetInformationErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetTypedLinkFacetInformationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::GetTypedLinkFacetInformationError {
meta: generic,
kind: crate::error::GetTypedLinkFacetInformationErrorKind::RetryableConflictException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetTypedLinkFacetInformationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ValidationException" => crate::error::GetTypedLinkFacetInformationError {
meta: generic,
kind: crate::error::GetTypedLinkFacetInformationErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetTypedLinkFacetInformationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetTypedLinkFacetInformationError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_typed_link_facet_information_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetTypedLinkFacetInformationOutput,
crate::error::GetTypedLinkFacetInformationError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_typed_link_facet_information_output::Builder::default();
let _ = response;
output =
crate::json_deser::deser_operation_crate_operation_get_typed_link_facet_information(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetTypedLinkFacetInformationError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_applied_schema_arns_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListAppliedSchemaArnsOutput,
crate::error::ListAppliedSchemaArnsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListAppliedSchemaArnsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListAppliedSchemaArnsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ListAppliedSchemaArnsError {
meta: generic,
kind: crate::error::ListAppliedSchemaArnsErrorKind::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::ListAppliedSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::ListAppliedSchemaArnsError {
meta: generic,
kind: crate::error::ListAppliedSchemaArnsErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAppliedSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::ListAppliedSchemaArnsError {
meta: generic,
kind: crate::error::ListAppliedSchemaArnsErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAppliedSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListAppliedSchemaArnsError {
meta: generic,
kind: crate::error::ListAppliedSchemaArnsErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAppliedSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::ListAppliedSchemaArnsError {
meta: generic,
kind: crate::error::ListAppliedSchemaArnsErrorKind::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::ListAppliedSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListAppliedSchemaArnsError {
meta: generic,
kind: crate::error::ListAppliedSchemaArnsErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAppliedSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::ListAppliedSchemaArnsError {
meta: generic,
kind: crate::error::ListAppliedSchemaArnsErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAppliedSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::ListAppliedSchemaArnsError {
meta: generic,
kind: crate::error::ListAppliedSchemaArnsErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAppliedSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListAppliedSchemaArnsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_applied_schema_arns_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListAppliedSchemaArnsOutput,
crate::error::ListAppliedSchemaArnsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_applied_schema_arns_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_applied_schema_arns(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListAppliedSchemaArnsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_attached_indices_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListAttachedIndicesOutput,
crate::error::ListAttachedIndicesError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListAttachedIndicesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListAttachedIndicesError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ListAttachedIndicesError {
meta: generic,
kind: crate::error::ListAttachedIndicesErrorKind::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::ListAttachedIndicesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::ListAttachedIndicesError {
meta: generic,
kind: crate::error::ListAttachedIndicesErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAttachedIndicesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::ListAttachedIndicesError {
meta: generic,
kind: crate::error::ListAttachedIndicesErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAttachedIndicesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::ListAttachedIndicesError {
meta: generic,
kind: crate::error::ListAttachedIndicesErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAttachedIndicesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::ListAttachedIndicesError {
meta: generic,
kind: crate::error::ListAttachedIndicesErrorKind::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::ListAttachedIndicesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListAttachedIndicesError {
meta: generic,
kind: crate::error::ListAttachedIndicesErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAttachedIndicesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::ListAttachedIndicesError {
meta: generic,
kind: crate::error::ListAttachedIndicesErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAttachedIndicesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::ListAttachedIndicesError {
meta: generic,
kind: crate::error::ListAttachedIndicesErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAttachedIndicesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListAttachedIndicesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_attached_indices_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListAttachedIndicesOutput,
crate::error::ListAttachedIndicesError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_attached_indices_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_attached_indices(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListAttachedIndicesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_development_schema_arns_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListDevelopmentSchemaArnsOutput,
crate::error::ListDevelopmentSchemaArnsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListDevelopmentSchemaArnsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListDevelopmentSchemaArnsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ListDevelopmentSchemaArnsError {
meta: generic,
kind: crate::error::ListDevelopmentSchemaArnsErrorKind::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::ListDevelopmentSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::ListDevelopmentSchemaArnsError {
meta: generic,
kind: crate::error::ListDevelopmentSchemaArnsErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDevelopmentSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::ListDevelopmentSchemaArnsError {
meta: generic,
kind: crate::error::ListDevelopmentSchemaArnsErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDevelopmentSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListDevelopmentSchemaArnsError {
meta: generic,
kind: crate::error::ListDevelopmentSchemaArnsErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDevelopmentSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::ListDevelopmentSchemaArnsError {
meta: generic,
kind: crate::error::ListDevelopmentSchemaArnsErrorKind::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::ListDevelopmentSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListDevelopmentSchemaArnsError {
meta: generic,
kind: crate::error::ListDevelopmentSchemaArnsErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDevelopmentSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::ListDevelopmentSchemaArnsError {
meta: generic,
kind: crate::error::ListDevelopmentSchemaArnsErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDevelopmentSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::ListDevelopmentSchemaArnsError {
meta: generic,
kind: crate::error::ListDevelopmentSchemaArnsErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDevelopmentSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListDevelopmentSchemaArnsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_development_schema_arns_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListDevelopmentSchemaArnsOutput,
crate::error::ListDevelopmentSchemaArnsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_development_schema_arns_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_development_schema_arns(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListDevelopmentSchemaArnsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_directories_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListDirectoriesOutput, crate::error::ListDirectoriesError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListDirectoriesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListDirectoriesError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ListDirectoriesError {
meta: generic,
kind: crate::error::ListDirectoriesErrorKind::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::ListDirectoriesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::ListDirectoriesError {
meta: generic,
kind: crate::error::ListDirectoriesErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDirectoriesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::ListDirectoriesError {
meta: generic,
kind: crate::error::ListDirectoriesErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDirectoriesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListDirectoriesError {
meta: generic,
kind: crate::error::ListDirectoriesErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDirectoriesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::ListDirectoriesError {
meta: generic,
kind: crate::error::ListDirectoriesErrorKind::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::ListDirectoriesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::ListDirectoriesError {
meta: generic,
kind: crate::error::ListDirectoriesErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDirectoriesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::ListDirectoriesError {
meta: generic,
kind: crate::error::ListDirectoriesErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDirectoriesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListDirectoriesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_directories_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListDirectoriesOutput, crate::error::ListDirectoriesError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_directories_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_directories(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListDirectoriesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_facet_attributes_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListFacetAttributesOutput,
crate::error::ListFacetAttributesError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListFacetAttributesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListFacetAttributesError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ListFacetAttributesError {
meta: generic,
kind: crate::error::ListFacetAttributesErrorKind::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::ListFacetAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetNotFoundException" => crate::error::ListFacetAttributesError {
meta: generic,
kind: crate::error::ListFacetAttributesErrorKind::FacetNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::facet_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListFacetAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::ListFacetAttributesError {
meta: generic,
kind: crate::error::ListFacetAttributesErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListFacetAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::ListFacetAttributesError {
meta: generic,
kind: crate::error::ListFacetAttributesErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListFacetAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListFacetAttributesError {
meta: generic,
kind: crate::error::ListFacetAttributesErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListFacetAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::ListFacetAttributesError {
meta: generic,
kind: crate::error::ListFacetAttributesErrorKind::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::ListFacetAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListFacetAttributesError {
meta: generic,
kind: crate::error::ListFacetAttributesErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListFacetAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::ListFacetAttributesError {
meta: generic,
kind: crate::error::ListFacetAttributesErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListFacetAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::ListFacetAttributesError {
meta: generic,
kind: crate::error::ListFacetAttributesErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListFacetAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListFacetAttributesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_facet_attributes_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListFacetAttributesOutput,
crate::error::ListFacetAttributesError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_facet_attributes_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_facet_attributes(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListFacetAttributesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_facet_names_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListFacetNamesOutput, crate::error::ListFacetNamesError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListFacetNamesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListFacetNamesError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ListFacetNamesError {
meta: generic,
kind: crate::error::ListFacetNamesErrorKind::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::ListFacetNamesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::ListFacetNamesError {
meta: generic,
kind: crate::error::ListFacetNamesErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListFacetNamesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::ListFacetNamesError {
meta: generic,
kind: crate::error::ListFacetNamesErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListFacetNamesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListFacetNamesError {
meta: generic,
kind: crate::error::ListFacetNamesErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListFacetNamesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::ListFacetNamesError {
meta: generic,
kind: crate::error::ListFacetNamesErrorKind::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::ListFacetNamesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListFacetNamesError {
meta: generic,
kind: crate::error::ListFacetNamesErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListFacetNamesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::ListFacetNamesError {
meta: generic,
kind: crate::error::ListFacetNamesErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListFacetNamesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::ListFacetNamesError {
meta: generic,
kind: crate::error::ListFacetNamesErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListFacetNamesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListFacetNamesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_facet_names_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListFacetNamesOutput, crate::error::ListFacetNamesError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_facet_names_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_facet_names(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListFacetNamesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_incoming_typed_links_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListIncomingTypedLinksOutput,
crate::error::ListIncomingTypedLinksError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListIncomingTypedLinksError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListIncomingTypedLinksError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ListIncomingTypedLinksError {
meta: generic,
kind: crate::error::ListIncomingTypedLinksErrorKind::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::ListIncomingTypedLinksError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::ListIncomingTypedLinksError {
meta: generic,
kind: crate::error::ListIncomingTypedLinksErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListIncomingTypedLinksError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetValidationException" => crate::error::ListIncomingTypedLinksError {
meta: generic,
kind: crate::error::ListIncomingTypedLinksErrorKind::FacetValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::facet_validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListIncomingTypedLinksError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::ListIncomingTypedLinksError {
meta: generic,
kind: crate::error::ListIncomingTypedLinksErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListIncomingTypedLinksError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::ListIncomingTypedLinksError {
meta: generic,
kind: crate::error::ListIncomingTypedLinksErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListIncomingTypedLinksError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListIncomingTypedLinksError {
meta: generic,
kind: crate::error::ListIncomingTypedLinksErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListIncomingTypedLinksError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::ListIncomingTypedLinksError {
meta: generic,
kind: crate::error::ListIncomingTypedLinksErrorKind::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::ListIncomingTypedLinksError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListIncomingTypedLinksError {
meta: generic,
kind: crate::error::ListIncomingTypedLinksErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListIncomingTypedLinksError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::ListIncomingTypedLinksError {
meta: generic,
kind: crate::error::ListIncomingTypedLinksErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListIncomingTypedLinksError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::ListIncomingTypedLinksError {
meta: generic,
kind: crate::error::ListIncomingTypedLinksErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListIncomingTypedLinksError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListIncomingTypedLinksError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_incoming_typed_links_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListIncomingTypedLinksOutput,
crate::error::ListIncomingTypedLinksError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_incoming_typed_links_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_incoming_typed_links(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListIncomingTypedLinksError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_index_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListIndexOutput, crate::error::ListIndexError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListIndexError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListIndexError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ListIndexError {
meta: generic,
kind: crate::error::ListIndexErrorKind::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::ListIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::ListIndexError {
meta: generic,
kind: crate::error::ListIndexErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetValidationException" => crate::error::ListIndexError {
meta: generic,
kind: crate::error::ListIndexErrorKind::FacetValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::facet_validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::ListIndexError {
meta: generic,
kind: crate::error::ListIndexErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::ListIndexError {
meta: generic,
kind: crate::error::ListIndexErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListIndexError {
meta: generic,
kind: crate::error::ListIndexErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::ListIndexError {
meta: generic,
kind: crate::error::ListIndexErrorKind::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::ListIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotIndexException" => crate::error::ListIndexError {
meta: generic,
kind: crate::error::ListIndexErrorKind::NotIndexException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_index_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_index_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListIndexError {
meta: generic,
kind: crate::error::ListIndexErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::ListIndexError {
meta: generic,
kind: crate::error::ListIndexErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::ListIndexError {
meta: generic,
kind: crate::error::ListIndexErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListIndexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListIndexError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_index_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListIndexOutput, crate::error::ListIndexError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_index_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_index(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListIndexError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_managed_schema_arns_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListManagedSchemaArnsOutput,
crate::error::ListManagedSchemaArnsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListManagedSchemaArnsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListManagedSchemaArnsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ListManagedSchemaArnsError {
meta: generic,
kind: crate::error::ListManagedSchemaArnsErrorKind::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::ListManagedSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::ListManagedSchemaArnsError {
meta: generic,
kind: crate::error::ListManagedSchemaArnsErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListManagedSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::ListManagedSchemaArnsError {
meta: generic,
kind: crate::error::ListManagedSchemaArnsErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListManagedSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListManagedSchemaArnsError {
meta: generic,
kind: crate::error::ListManagedSchemaArnsErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListManagedSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListManagedSchemaArnsError {
meta: generic,
kind: crate::error::ListManagedSchemaArnsErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListManagedSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::ListManagedSchemaArnsError {
meta: generic,
kind: crate::error::ListManagedSchemaArnsErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListManagedSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListManagedSchemaArnsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_managed_schema_arns_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListManagedSchemaArnsOutput,
crate::error::ListManagedSchemaArnsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_managed_schema_arns_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_managed_schema_arns(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListManagedSchemaArnsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_object_attributes_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListObjectAttributesOutput,
crate::error::ListObjectAttributesError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListObjectAttributesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListObjectAttributesError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ListObjectAttributesError {
meta: generic,
kind: crate::error::ListObjectAttributesErrorKind::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::ListObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::ListObjectAttributesError {
meta: generic,
kind: crate::error::ListObjectAttributesErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetValidationException" => crate::error::ListObjectAttributesError {
meta: generic,
kind: crate::error::ListObjectAttributesErrorKind::FacetValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::facet_validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::ListObjectAttributesError {
meta: generic,
kind: crate::error::ListObjectAttributesErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::ListObjectAttributesError {
meta: generic,
kind: crate::error::ListObjectAttributesErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListObjectAttributesError {
meta: generic,
kind: crate::error::ListObjectAttributesErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::ListObjectAttributesError {
meta: generic,
kind: crate::error::ListObjectAttributesErrorKind::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::ListObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListObjectAttributesError {
meta: generic,
kind: crate::error::ListObjectAttributesErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::ListObjectAttributesError {
meta: generic,
kind: crate::error::ListObjectAttributesErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::ListObjectAttributesError {
meta: generic,
kind: crate::error::ListObjectAttributesErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListObjectAttributesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_object_attributes_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListObjectAttributesOutput,
crate::error::ListObjectAttributesError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_object_attributes_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_object_attributes(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListObjectAttributesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_object_children_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListObjectChildrenOutput,
crate::error::ListObjectChildrenError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListObjectChildrenError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListObjectChildrenError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ListObjectChildrenError {
meta: generic,
kind: crate::error::ListObjectChildrenErrorKind::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::ListObjectChildrenError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::ListObjectChildrenError {
meta: generic,
kind: crate::error::ListObjectChildrenErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectChildrenError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::ListObjectChildrenError {
meta: generic,
kind: crate::error::ListObjectChildrenErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectChildrenError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::ListObjectChildrenError {
meta: generic,
kind: crate::error::ListObjectChildrenErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectChildrenError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListObjectChildrenError {
meta: generic,
kind: crate::error::ListObjectChildrenErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectChildrenError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::ListObjectChildrenError {
meta: generic,
kind: crate::error::ListObjectChildrenErrorKind::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::ListObjectChildrenError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotNodeException" => {
crate::error::ListObjectChildrenError {
meta: generic,
kind: crate::error::ListObjectChildrenErrorKind::NotNodeException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_node_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_node_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectChildrenError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ResourceNotFoundException" => crate::error::ListObjectChildrenError {
meta: generic,
kind: crate::error::ListObjectChildrenErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectChildrenError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::ListObjectChildrenError {
meta: generic,
kind: crate::error::ListObjectChildrenErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectChildrenError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::ListObjectChildrenError {
meta: generic,
kind: crate::error::ListObjectChildrenErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectChildrenError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListObjectChildrenError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_object_children_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListObjectChildrenOutput,
crate::error::ListObjectChildrenError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_object_children_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_object_children(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListObjectChildrenError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_object_parent_paths_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListObjectParentPathsOutput,
crate::error::ListObjectParentPathsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListObjectParentPathsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListObjectParentPathsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ListObjectParentPathsError {
meta: generic,
kind: crate::error::ListObjectParentPathsErrorKind::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::ListObjectParentPathsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::ListObjectParentPathsError {
meta: generic,
kind: crate::error::ListObjectParentPathsErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectParentPathsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::ListObjectParentPathsError {
meta: generic,
kind: crate::error::ListObjectParentPathsErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectParentPathsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::ListObjectParentPathsError {
meta: generic,
kind: crate::error::ListObjectParentPathsErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectParentPathsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListObjectParentPathsError {
meta: generic,
kind: crate::error::ListObjectParentPathsErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectParentPathsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::ListObjectParentPathsError {
meta: generic,
kind: crate::error::ListObjectParentPathsErrorKind::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::ListObjectParentPathsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListObjectParentPathsError {
meta: generic,
kind: crate::error::ListObjectParentPathsErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectParentPathsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::ListObjectParentPathsError {
meta: generic,
kind: crate::error::ListObjectParentPathsErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectParentPathsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::ListObjectParentPathsError {
meta: generic,
kind: crate::error::ListObjectParentPathsErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectParentPathsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListObjectParentPathsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_object_parent_paths_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListObjectParentPathsOutput,
crate::error::ListObjectParentPathsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_object_parent_paths_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_object_parent_paths(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListObjectParentPathsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_object_parents_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListObjectParentsOutput, crate::error::ListObjectParentsError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListObjectParentsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListObjectParentsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ListObjectParentsError {
meta: generic,
kind: crate::error::ListObjectParentsErrorKind::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::ListObjectParentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"CannotListParentOfRootException" => crate::error::ListObjectParentsError {
meta: generic,
kind: crate::error::ListObjectParentsErrorKind::CannotListParentOfRootException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::cannot_list_parent_of_root_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_cannot_list_parent_of_root_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectParentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::ListObjectParentsError {
meta: generic,
kind: crate::error::ListObjectParentsErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectParentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::ListObjectParentsError {
meta: generic,
kind: crate::error::ListObjectParentsErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectParentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::ListObjectParentsError {
meta: generic,
kind: crate::error::ListObjectParentsErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectParentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListObjectParentsError {
meta: generic,
kind: crate::error::ListObjectParentsErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectParentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::ListObjectParentsError {
meta: generic,
kind: crate::error::ListObjectParentsErrorKind::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::ListObjectParentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListObjectParentsError {
meta: generic,
kind: crate::error::ListObjectParentsErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectParentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::ListObjectParentsError {
meta: generic,
kind: crate::error::ListObjectParentsErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectParentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::ListObjectParentsError {
meta: generic,
kind: crate::error::ListObjectParentsErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectParentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListObjectParentsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_object_parents_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListObjectParentsOutput, crate::error::ListObjectParentsError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_object_parents_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_object_parents(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListObjectParentsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_object_policies_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListObjectPoliciesOutput,
crate::error::ListObjectPoliciesError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListObjectPoliciesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListObjectPoliciesError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ListObjectPoliciesError {
meta: generic,
kind: crate::error::ListObjectPoliciesErrorKind::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::ListObjectPoliciesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::ListObjectPoliciesError {
meta: generic,
kind: crate::error::ListObjectPoliciesErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectPoliciesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::ListObjectPoliciesError {
meta: generic,
kind: crate::error::ListObjectPoliciesErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectPoliciesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::ListObjectPoliciesError {
meta: generic,
kind: crate::error::ListObjectPoliciesErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectPoliciesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListObjectPoliciesError {
meta: generic,
kind: crate::error::ListObjectPoliciesErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectPoliciesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::ListObjectPoliciesError {
meta: generic,
kind: crate::error::ListObjectPoliciesErrorKind::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::ListObjectPoliciesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListObjectPoliciesError {
meta: generic,
kind: crate::error::ListObjectPoliciesErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectPoliciesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::ListObjectPoliciesError {
meta: generic,
kind: crate::error::ListObjectPoliciesErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectPoliciesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::ListObjectPoliciesError {
meta: generic,
kind: crate::error::ListObjectPoliciesErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListObjectPoliciesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListObjectPoliciesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_object_policies_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListObjectPoliciesOutput,
crate::error::ListObjectPoliciesError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_object_policies_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_object_policies(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListObjectPoliciesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_outgoing_typed_links_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListOutgoingTypedLinksOutput,
crate::error::ListOutgoingTypedLinksError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListOutgoingTypedLinksError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListOutgoingTypedLinksError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ListOutgoingTypedLinksError {
meta: generic,
kind: crate::error::ListOutgoingTypedLinksErrorKind::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::ListOutgoingTypedLinksError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::ListOutgoingTypedLinksError {
meta: generic,
kind: crate::error::ListOutgoingTypedLinksErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListOutgoingTypedLinksError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetValidationException" => crate::error::ListOutgoingTypedLinksError {
meta: generic,
kind: crate::error::ListOutgoingTypedLinksErrorKind::FacetValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::facet_validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListOutgoingTypedLinksError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::ListOutgoingTypedLinksError {
meta: generic,
kind: crate::error::ListOutgoingTypedLinksErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListOutgoingTypedLinksError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::ListOutgoingTypedLinksError {
meta: generic,
kind: crate::error::ListOutgoingTypedLinksErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListOutgoingTypedLinksError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListOutgoingTypedLinksError {
meta: generic,
kind: crate::error::ListOutgoingTypedLinksErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListOutgoingTypedLinksError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::ListOutgoingTypedLinksError {
meta: generic,
kind: crate::error::ListOutgoingTypedLinksErrorKind::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::ListOutgoingTypedLinksError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListOutgoingTypedLinksError {
meta: generic,
kind: crate::error::ListOutgoingTypedLinksErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListOutgoingTypedLinksError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::ListOutgoingTypedLinksError {
meta: generic,
kind: crate::error::ListOutgoingTypedLinksErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListOutgoingTypedLinksError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::ListOutgoingTypedLinksError {
meta: generic,
kind: crate::error::ListOutgoingTypedLinksErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListOutgoingTypedLinksError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListOutgoingTypedLinksError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_outgoing_typed_links_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListOutgoingTypedLinksOutput,
crate::error::ListOutgoingTypedLinksError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_outgoing_typed_links_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_outgoing_typed_links(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListOutgoingTypedLinksError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_policy_attachments_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListPolicyAttachmentsOutput,
crate::error::ListPolicyAttachmentsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListPolicyAttachmentsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListPolicyAttachmentsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ListPolicyAttachmentsError {
meta: generic,
kind: crate::error::ListPolicyAttachmentsErrorKind::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::ListPolicyAttachmentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::ListPolicyAttachmentsError {
meta: generic,
kind: crate::error::ListPolicyAttachmentsErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListPolicyAttachmentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::ListPolicyAttachmentsError {
meta: generic,
kind: crate::error::ListPolicyAttachmentsErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListPolicyAttachmentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::ListPolicyAttachmentsError {
meta: generic,
kind: crate::error::ListPolicyAttachmentsErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListPolicyAttachmentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListPolicyAttachmentsError {
meta: generic,
kind: crate::error::ListPolicyAttachmentsErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListPolicyAttachmentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::ListPolicyAttachmentsError {
meta: generic,
kind: crate::error::ListPolicyAttachmentsErrorKind::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::ListPolicyAttachmentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotPolicyException" => crate::error::ListPolicyAttachmentsError {
meta: generic,
kind: crate::error::ListPolicyAttachmentsErrorKind::NotPolicyException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_policy_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_policy_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListPolicyAttachmentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListPolicyAttachmentsError {
meta: generic,
kind: crate::error::ListPolicyAttachmentsErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListPolicyAttachmentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::ListPolicyAttachmentsError {
meta: generic,
kind: crate::error::ListPolicyAttachmentsErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListPolicyAttachmentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::ListPolicyAttachmentsError {
meta: generic,
kind: crate::error::ListPolicyAttachmentsErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListPolicyAttachmentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListPolicyAttachmentsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_policy_attachments_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListPolicyAttachmentsOutput,
crate::error::ListPolicyAttachmentsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_policy_attachments_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_policy_attachments(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListPolicyAttachmentsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_published_schema_arns_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListPublishedSchemaArnsOutput,
crate::error::ListPublishedSchemaArnsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListPublishedSchemaArnsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListPublishedSchemaArnsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ListPublishedSchemaArnsError {
meta: generic,
kind: crate::error::ListPublishedSchemaArnsErrorKind::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::ListPublishedSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::ListPublishedSchemaArnsError {
meta: generic,
kind: crate::error::ListPublishedSchemaArnsErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListPublishedSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::ListPublishedSchemaArnsError {
meta: generic,
kind: crate::error::ListPublishedSchemaArnsErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListPublishedSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListPublishedSchemaArnsError {
meta: generic,
kind: crate::error::ListPublishedSchemaArnsErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListPublishedSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::ListPublishedSchemaArnsError {
meta: generic,
kind: crate::error::ListPublishedSchemaArnsErrorKind::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::ListPublishedSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListPublishedSchemaArnsError {
meta: generic,
kind: crate::error::ListPublishedSchemaArnsErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListPublishedSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::ListPublishedSchemaArnsError {
meta: generic,
kind: crate::error::ListPublishedSchemaArnsErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListPublishedSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::ListPublishedSchemaArnsError {
meta: generic,
kind: crate::error::ListPublishedSchemaArnsErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListPublishedSchemaArnsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListPublishedSchemaArnsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_published_schema_arns_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListPublishedSchemaArnsOutput,
crate::error::ListPublishedSchemaArnsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_published_schema_arns_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_published_schema_arns(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListPublishedSchemaArnsError::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
}),
},
"InternalServiceException" => crate::error::ListTagsForResourceError {
meta: generic,
kind: crate::error::ListTagsForResourceErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_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
}),
},
"InvalidArnException" => crate::error::ListTagsForResourceError {
meta: generic,
kind: crate::error::ListTagsForResourceErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTagsForResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidTaggingRequestException" => crate::error::ListTagsForResourceError {
meta: generic,
kind: crate::error::ListTagsForResourceErrorKind::InvalidTaggingRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_tagging_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_tagging_request_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
}),
},
"LimitExceededException" => crate::error::ListTagsForResourceError {
meta: generic,
kind: crate::error::ListTagsForResourceErrorKind::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::ListTagsForResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListTagsForResourceError {
meta: generic,
kind: crate::error::ListTagsForResourceErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTagsForResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::ListTagsForResourceError {
meta: generic,
kind: crate::error::ListTagsForResourceErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_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
}),
},
"ValidationException" => crate::error::ListTagsForResourceError {
meta: generic,
kind: crate::error::ListTagsForResourceErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::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_list_typed_link_facet_attributes_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListTypedLinkFacetAttributesOutput,
crate::error::ListTypedLinkFacetAttributesError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListTypedLinkFacetAttributesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListTypedLinkFacetAttributesError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ListTypedLinkFacetAttributesError {
meta: generic,
kind: crate::error::ListTypedLinkFacetAttributesErrorKind::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::ListTypedLinkFacetAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetNotFoundException" => crate::error::ListTypedLinkFacetAttributesError {
meta: generic,
kind: crate::error::ListTypedLinkFacetAttributesErrorKind::FacetNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::facet_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTypedLinkFacetAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::ListTypedLinkFacetAttributesError {
meta: generic,
kind: crate::error::ListTypedLinkFacetAttributesErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTypedLinkFacetAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::ListTypedLinkFacetAttributesError {
meta: generic,
kind: crate::error::ListTypedLinkFacetAttributesErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTypedLinkFacetAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListTypedLinkFacetAttributesError {
meta: generic,
kind: crate::error::ListTypedLinkFacetAttributesErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTypedLinkFacetAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::ListTypedLinkFacetAttributesError {
meta: generic,
kind: crate::error::ListTypedLinkFacetAttributesErrorKind::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::ListTypedLinkFacetAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListTypedLinkFacetAttributesError {
meta: generic,
kind: crate::error::ListTypedLinkFacetAttributesErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTypedLinkFacetAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::ListTypedLinkFacetAttributesError {
meta: generic,
kind: crate::error::ListTypedLinkFacetAttributesErrorKind::RetryableConflictException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTypedLinkFacetAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ValidationException" => crate::error::ListTypedLinkFacetAttributesError {
meta: generic,
kind: crate::error::ListTypedLinkFacetAttributesErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTypedLinkFacetAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListTypedLinkFacetAttributesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_typed_link_facet_attributes_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListTypedLinkFacetAttributesOutput,
crate::error::ListTypedLinkFacetAttributesError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_typed_link_facet_attributes_output::Builder::default();
let _ = response;
output =
crate::json_deser::deser_operation_crate_operation_list_typed_link_facet_attributes(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListTypedLinkFacetAttributesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_typed_link_facet_names_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListTypedLinkFacetNamesOutput,
crate::error::ListTypedLinkFacetNamesError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListTypedLinkFacetNamesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListTypedLinkFacetNamesError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ListTypedLinkFacetNamesError {
meta: generic,
kind: crate::error::ListTypedLinkFacetNamesErrorKind::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::ListTypedLinkFacetNamesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::ListTypedLinkFacetNamesError {
meta: generic,
kind: crate::error::ListTypedLinkFacetNamesErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTypedLinkFacetNamesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::ListTypedLinkFacetNamesError {
meta: generic,
kind: crate::error::ListTypedLinkFacetNamesErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTypedLinkFacetNamesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListTypedLinkFacetNamesError {
meta: generic,
kind: crate::error::ListTypedLinkFacetNamesErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTypedLinkFacetNamesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::ListTypedLinkFacetNamesError {
meta: generic,
kind: crate::error::ListTypedLinkFacetNamesErrorKind::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::ListTypedLinkFacetNamesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListTypedLinkFacetNamesError {
meta: generic,
kind: crate::error::ListTypedLinkFacetNamesErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTypedLinkFacetNamesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::ListTypedLinkFacetNamesError {
meta: generic,
kind: crate::error::ListTypedLinkFacetNamesErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTypedLinkFacetNamesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::ListTypedLinkFacetNamesError {
meta: generic,
kind: crate::error::ListTypedLinkFacetNamesErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTypedLinkFacetNamesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListTypedLinkFacetNamesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_typed_link_facet_names_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListTypedLinkFacetNamesOutput,
crate::error::ListTypedLinkFacetNamesError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_typed_link_facet_names_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_typed_link_facet_names(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListTypedLinkFacetNamesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_lookup_policy_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::LookupPolicyOutput, crate::error::LookupPolicyError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::LookupPolicyError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::LookupPolicyError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::LookupPolicyError {
meta: generic,
kind: crate::error::LookupPolicyErrorKind::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::LookupPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::LookupPolicyError {
meta: generic,
kind: crate::error::LookupPolicyErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::LookupPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::LookupPolicyError {
meta: generic,
kind: crate::error::LookupPolicyErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::LookupPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::LookupPolicyError {
meta: generic,
kind: crate::error::LookupPolicyErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::LookupPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::LookupPolicyError {
meta: generic,
kind: crate::error::LookupPolicyErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::LookupPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::LookupPolicyError {
meta: generic,
kind: crate::error::LookupPolicyErrorKind::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::LookupPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::LookupPolicyError {
meta: generic,
kind: crate::error::LookupPolicyErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::LookupPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::LookupPolicyError {
meta: generic,
kind: crate::error::LookupPolicyErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::LookupPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::LookupPolicyError {
meta: generic,
kind: crate::error::LookupPolicyErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::LookupPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::LookupPolicyError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_lookup_policy_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::LookupPolicyOutput, crate::error::LookupPolicyError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::lookup_policy_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_lookup_policy(
response.body().as_ref(),
output,
)
.map_err(crate::error::LookupPolicyError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_publish_schema_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::PublishSchemaOutput, crate::error::PublishSchemaError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::PublishSchemaError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::PublishSchemaError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::PublishSchemaError {
meta: generic,
kind: crate::error::PublishSchemaErrorKind::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::PublishSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::PublishSchemaError {
meta: generic,
kind: crate::error::PublishSchemaErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PublishSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::PublishSchemaError {
meta: generic,
kind: crate::error::PublishSchemaErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PublishSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::PublishSchemaError {
meta: generic,
kind: crate::error::PublishSchemaErrorKind::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::PublishSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::PublishSchemaError {
meta: generic,
kind: crate::error::PublishSchemaErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PublishSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::PublishSchemaError {
meta: generic,
kind: crate::error::PublishSchemaErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PublishSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"SchemaAlreadyPublishedException" => crate::error::PublishSchemaError {
meta: generic,
kind: crate::error::PublishSchemaErrorKind::SchemaAlreadyPublishedException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::schema_already_published_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_schema_already_published_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PublishSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::PublishSchemaError {
meta: generic,
kind: crate::error::PublishSchemaErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PublishSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::PublishSchemaError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_publish_schema_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::PublishSchemaOutput, crate::error::PublishSchemaError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::publish_schema_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_publish_schema(
response.body().as_ref(),
output,
)
.map_err(crate::error::PublishSchemaError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_put_schema_from_json_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::PutSchemaFromJsonOutput, crate::error::PutSchemaFromJsonError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::PutSchemaFromJsonError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::PutSchemaFromJsonError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::PutSchemaFromJsonError {
meta: generic,
kind: crate::error::PutSchemaFromJsonErrorKind::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::PutSchemaFromJsonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::PutSchemaFromJsonError {
meta: generic,
kind: crate::error::PutSchemaFromJsonErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutSchemaFromJsonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::PutSchemaFromJsonError {
meta: generic,
kind: crate::error::PutSchemaFromJsonErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutSchemaFromJsonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRuleException" => crate::error::PutSchemaFromJsonError {
meta: generic,
kind: crate::error::PutSchemaFromJsonErrorKind::InvalidRuleException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_rule_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_rule_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutSchemaFromJsonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidSchemaDocException" => crate::error::PutSchemaFromJsonError {
meta: generic,
kind: crate::error::PutSchemaFromJsonErrorKind::InvalidSchemaDocException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_schema_doc_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_schema_doc_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutSchemaFromJsonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::PutSchemaFromJsonError {
meta: generic,
kind: crate::error::PutSchemaFromJsonErrorKind::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::PutSchemaFromJsonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::PutSchemaFromJsonError {
meta: generic,
kind: crate::error::PutSchemaFromJsonErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutSchemaFromJsonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::PutSchemaFromJsonError {
meta: generic,
kind: crate::error::PutSchemaFromJsonErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutSchemaFromJsonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::PutSchemaFromJsonError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_put_schema_from_json_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::PutSchemaFromJsonOutput, crate::error::PutSchemaFromJsonError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::put_schema_from_json_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_put_schema_from_json(
response.body().as_ref(),
output,
)
.map_err(crate::error::PutSchemaFromJsonError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_remove_facet_from_object_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::RemoveFacetFromObjectOutput,
crate::error::RemoveFacetFromObjectError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::RemoveFacetFromObjectError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::RemoveFacetFromObjectError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::RemoveFacetFromObjectError {
meta: generic,
kind: crate::error::RemoveFacetFromObjectErrorKind::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::RemoveFacetFromObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::RemoveFacetFromObjectError {
meta: generic,
kind: crate::error::RemoveFacetFromObjectErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RemoveFacetFromObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetValidationException" => crate::error::RemoveFacetFromObjectError {
meta: generic,
kind: crate::error::RemoveFacetFromObjectErrorKind::FacetValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::facet_validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RemoveFacetFromObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::RemoveFacetFromObjectError {
meta: generic,
kind: crate::error::RemoveFacetFromObjectErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RemoveFacetFromObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::RemoveFacetFromObjectError {
meta: generic,
kind: crate::error::RemoveFacetFromObjectErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RemoveFacetFromObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::RemoveFacetFromObjectError {
meta: generic,
kind: crate::error::RemoveFacetFromObjectErrorKind::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::RemoveFacetFromObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::RemoveFacetFromObjectError {
meta: generic,
kind: crate::error::RemoveFacetFromObjectErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RemoveFacetFromObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::RemoveFacetFromObjectError {
meta: generic,
kind: crate::error::RemoveFacetFromObjectErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RemoveFacetFromObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::RemoveFacetFromObjectError {
meta: generic,
kind: crate::error::RemoveFacetFromObjectErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RemoveFacetFromObjectError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::RemoveFacetFromObjectError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_remove_facet_from_object_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::RemoveFacetFromObjectOutput,
crate::error::RemoveFacetFromObjectError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::remove_facet_from_object_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_tag_resource_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::TagResourceOutput, crate::error::TagResourceError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::TagResourceError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::TagResourceError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::TagResourceError {
meta: generic,
kind: crate::error::TagResourceErrorKind::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::TagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::TagResourceError {
meta: generic,
kind: crate::error::TagResourceErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::TagResourceError {
meta: generic,
kind: crate::error::TagResourceErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidTaggingRequestException" => crate::error::TagResourceError {
meta: generic,
kind: crate::error::TagResourceErrorKind::InvalidTaggingRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_tagging_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_tagging_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::TagResourceError {
meta: generic,
kind: crate::error::TagResourceErrorKind::LimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::TagResourceError {
meta: generic,
kind: crate::error::TagResourceErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::TagResourceError {
meta: generic,
kind: crate::error::TagResourceErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::TagResourceError {
meta: generic,
kind: crate::error::TagResourceErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::TagResourceError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_tag_resource_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::TagResourceOutput, crate::error::TagResourceError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::tag_resource_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_untag_resource_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UntagResourceOutput, crate::error::UntagResourceError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UntagResourceError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UntagResourceError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::UntagResourceError {
meta: generic,
kind: crate::error::UntagResourceErrorKind::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::UntagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::UntagResourceError {
meta: generic,
kind: crate::error::UntagResourceErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UntagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::UntagResourceError {
meta: generic,
kind: crate::error::UntagResourceErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UntagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidTaggingRequestException" => crate::error::UntagResourceError {
meta: generic,
kind: crate::error::UntagResourceErrorKind::InvalidTaggingRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_tagging_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_tagging_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UntagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::UntagResourceError {
meta: generic,
kind: crate::error::UntagResourceErrorKind::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::UntagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UntagResourceError {
meta: generic,
kind: crate::error::UntagResourceErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UntagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::UntagResourceError {
meta: generic,
kind: crate::error::UntagResourceErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UntagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::UntagResourceError {
meta: generic,
kind: crate::error::UntagResourceErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UntagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UntagResourceError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_untag_resource_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UntagResourceOutput, crate::error::UntagResourceError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::untag_resource_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_facet_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateFacetOutput, crate::error::UpdateFacetError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateFacetError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UpdateFacetError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::UpdateFacetError {
meta: generic,
kind: crate::error::UpdateFacetErrorKind::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::UpdateFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetNotFoundException" => crate::error::UpdateFacetError {
meta: generic,
kind: crate::error::UpdateFacetErrorKind::FacetNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::facet_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetValidationException" => crate::error::UpdateFacetError {
meta: generic,
kind: crate::error::UpdateFacetErrorKind::FacetValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::facet_validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::UpdateFacetError {
meta: generic,
kind: crate::error::UpdateFacetErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::UpdateFacetError {
meta: generic,
kind: crate::error::UpdateFacetErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidFacetUpdateException" => crate::error::UpdateFacetError {
meta: generic,
kind: crate::error::UpdateFacetErrorKind::InvalidFacetUpdateException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_facet_update_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_facet_update_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRuleException" => crate::error::UpdateFacetError {
meta: generic,
kind: crate::error::UpdateFacetErrorKind::InvalidRuleException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_rule_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_rule_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::UpdateFacetError {
meta: generic,
kind: crate::error::UpdateFacetErrorKind::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::UpdateFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpdateFacetError {
meta: generic,
kind: crate::error::UpdateFacetErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::UpdateFacetError {
meta: generic,
kind: crate::error::UpdateFacetErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::UpdateFacetError {
meta: generic,
kind: crate::error::UpdateFacetErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateFacetError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_facet_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateFacetOutput, crate::error::UpdateFacetError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_facet_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_link_attributes_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateLinkAttributesOutput,
crate::error::UpdateLinkAttributesError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateLinkAttributesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UpdateLinkAttributesError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::UpdateLinkAttributesError {
meta: generic,
kind: crate::error::UpdateLinkAttributesErrorKind::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::UpdateLinkAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::UpdateLinkAttributesError {
meta: generic,
kind: crate::error::UpdateLinkAttributesErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateLinkAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetValidationException" => crate::error::UpdateLinkAttributesError {
meta: generic,
kind: crate::error::UpdateLinkAttributesErrorKind::FacetValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::facet_validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateLinkAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::UpdateLinkAttributesError {
meta: generic,
kind: crate::error::UpdateLinkAttributesErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateLinkAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::UpdateLinkAttributesError {
meta: generic,
kind: crate::error::UpdateLinkAttributesErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateLinkAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::UpdateLinkAttributesError {
meta: generic,
kind: crate::error::UpdateLinkAttributesErrorKind::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::UpdateLinkAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpdateLinkAttributesError {
meta: generic,
kind: crate::error::UpdateLinkAttributesErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateLinkAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::UpdateLinkAttributesError {
meta: generic,
kind: crate::error::UpdateLinkAttributesErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateLinkAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::UpdateLinkAttributesError {
meta: generic,
kind: crate::error::UpdateLinkAttributesErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateLinkAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateLinkAttributesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_link_attributes_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateLinkAttributesOutput,
crate::error::UpdateLinkAttributesError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_link_attributes_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_object_attributes_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateObjectAttributesOutput,
crate::error::UpdateObjectAttributesError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateObjectAttributesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::UpdateObjectAttributesError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::UpdateObjectAttributesError {
meta: generic,
kind: crate::error::UpdateObjectAttributesErrorKind::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::UpdateObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"DirectoryNotEnabledException" => crate::error::UpdateObjectAttributesError {
meta: generic,
kind: crate::error::UpdateObjectAttributesErrorKind::DirectoryNotEnabledException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::directory_not_enabled_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_directory_not_enabled_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetValidationException" => crate::error::UpdateObjectAttributesError {
meta: generic,
kind: crate::error::UpdateObjectAttributesErrorKind::FacetValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::facet_validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::UpdateObjectAttributesError {
meta: generic,
kind: crate::error::UpdateObjectAttributesErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::UpdateObjectAttributesError {
meta: generic,
kind: crate::error::UpdateObjectAttributesErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::UpdateObjectAttributesError {
meta: generic,
kind: crate::error::UpdateObjectAttributesErrorKind::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::UpdateObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LinkNameAlreadyInUseException" => crate::error::UpdateObjectAttributesError {
meta: generic,
kind: crate::error::UpdateObjectAttributesErrorKind::LinkNameAlreadyInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::link_name_already_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_link_name_already_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpdateObjectAttributesError {
meta: generic,
kind: crate::error::UpdateObjectAttributesErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::UpdateObjectAttributesError {
meta: generic,
kind: crate::error::UpdateObjectAttributesErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::UpdateObjectAttributesError {
meta: generic,
kind: crate::error::UpdateObjectAttributesErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateObjectAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateObjectAttributesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_object_attributes_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateObjectAttributesOutput,
crate::error::UpdateObjectAttributesError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_object_attributes_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_object_attributes(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateObjectAttributesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_schema_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateSchemaOutput, crate::error::UpdateSchemaError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateSchemaError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UpdateSchemaError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::UpdateSchemaError {
meta: generic,
kind: crate::error::UpdateSchemaErrorKind::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::UpdateSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::UpdateSchemaError {
meta: generic,
kind: crate::error::UpdateSchemaErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::UpdateSchemaError {
meta: generic,
kind: crate::error::UpdateSchemaErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::UpdateSchemaError {
meta: generic,
kind: crate::error::UpdateSchemaErrorKind::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::UpdateSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpdateSchemaError {
meta: generic,
kind: crate::error::UpdateSchemaErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::UpdateSchemaError {
meta: generic,
kind: crate::error::UpdateSchemaErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::UpdateSchemaError {
meta: generic,
kind: crate::error::UpdateSchemaErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateSchemaError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_schema_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateSchemaOutput, crate::error::UpdateSchemaError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_schema_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_schema(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateSchemaError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_typed_link_facet_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateTypedLinkFacetOutput,
crate::error::UpdateTypedLinkFacetError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateTypedLinkFacetError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UpdateTypedLinkFacetError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::UpdateTypedLinkFacetError {
meta: generic,
kind: crate::error::UpdateTypedLinkFacetErrorKind::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::UpdateTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetNotFoundException" => crate::error::UpdateTypedLinkFacetError {
meta: generic,
kind: crate::error::UpdateTypedLinkFacetErrorKind::FacetNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::facet_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"FacetValidationException" => crate::error::UpdateTypedLinkFacetError {
meta: generic,
kind: crate::error::UpdateTypedLinkFacetErrorKind::FacetValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::facet_validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_facet_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::UpdateTypedLinkFacetError {
meta: generic,
kind: crate::error::UpdateTypedLinkFacetErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::UpdateTypedLinkFacetError {
meta: generic,
kind: crate::error::UpdateTypedLinkFacetErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidFacetUpdateException" => crate::error::UpdateTypedLinkFacetError {
meta: generic,
kind: crate::error::UpdateTypedLinkFacetErrorKind::InvalidFacetUpdateException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_facet_update_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_facet_update_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRuleException" => crate::error::UpdateTypedLinkFacetError {
meta: generic,
kind: crate::error::UpdateTypedLinkFacetErrorKind::InvalidRuleException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_rule_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_rule_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::UpdateTypedLinkFacetError {
meta: generic,
kind: crate::error::UpdateTypedLinkFacetErrorKind::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::UpdateTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpdateTypedLinkFacetError {
meta: generic,
kind: crate::error::UpdateTypedLinkFacetErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::UpdateTypedLinkFacetError {
meta: generic,
kind: crate::error::UpdateTypedLinkFacetErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::UpdateTypedLinkFacetError {
meta: generic,
kind: crate::error::UpdateTypedLinkFacetErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateTypedLinkFacetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateTypedLinkFacetError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_typed_link_facet_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateTypedLinkFacetOutput,
crate::error::UpdateTypedLinkFacetError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_typed_link_facet_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_upgrade_applied_schema_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpgradeAppliedSchemaOutput,
crate::error::UpgradeAppliedSchemaError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpgradeAppliedSchemaError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UpgradeAppliedSchemaError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::UpgradeAppliedSchemaError {
meta: generic,
kind: crate::error::UpgradeAppliedSchemaErrorKind::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::UpgradeAppliedSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"IncompatibleSchemaException" => crate::error::UpgradeAppliedSchemaError {
meta: generic,
kind: crate::error::UpgradeAppliedSchemaErrorKind::IncompatibleSchemaException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::incompatible_schema_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_incompatible_schema_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpgradeAppliedSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::UpgradeAppliedSchemaError {
meta: generic,
kind: crate::error::UpgradeAppliedSchemaErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpgradeAppliedSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::UpgradeAppliedSchemaError {
meta: generic,
kind: crate::error::UpgradeAppliedSchemaErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpgradeAppliedSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidAttachmentException" => crate::error::UpgradeAppliedSchemaError {
meta: generic,
kind: crate::error::UpgradeAppliedSchemaErrorKind::InvalidAttachmentException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_attachment_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_attachment_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpgradeAppliedSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpgradeAppliedSchemaError {
meta: generic,
kind: crate::error::UpgradeAppliedSchemaErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpgradeAppliedSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::UpgradeAppliedSchemaError {
meta: generic,
kind: crate::error::UpgradeAppliedSchemaErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpgradeAppliedSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"SchemaAlreadyExistsException" => crate::error::UpgradeAppliedSchemaError {
meta: generic,
kind: crate::error::UpgradeAppliedSchemaErrorKind::SchemaAlreadyExistsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::schema_already_exists_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_schema_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpgradeAppliedSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::UpgradeAppliedSchemaError {
meta: generic,
kind: crate::error::UpgradeAppliedSchemaErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpgradeAppliedSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpgradeAppliedSchemaError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_upgrade_applied_schema_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpgradeAppliedSchemaOutput,
crate::error::UpgradeAppliedSchemaError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::upgrade_applied_schema_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_upgrade_applied_schema(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpgradeAppliedSchemaError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_upgrade_published_schema_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpgradePublishedSchemaOutput,
crate::error::UpgradePublishedSchemaError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpgradePublishedSchemaError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::UpgradePublishedSchemaError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::UpgradePublishedSchemaError {
meta: generic,
kind: crate::error::UpgradePublishedSchemaErrorKind::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::UpgradePublishedSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"IncompatibleSchemaException" => crate::error::UpgradePublishedSchemaError {
meta: generic,
kind: crate::error::UpgradePublishedSchemaErrorKind::IncompatibleSchemaException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::incompatible_schema_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_incompatible_schema_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpgradePublishedSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServiceException" => crate::error::UpgradePublishedSchemaError {
meta: generic,
kind: crate::error::UpgradePublishedSchemaErrorKind::InternalServiceException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpgradePublishedSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidArnException" => crate::error::UpgradePublishedSchemaError {
meta: generic,
kind: crate::error::UpgradePublishedSchemaErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpgradePublishedSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidAttachmentException" => crate::error::UpgradePublishedSchemaError {
meta: generic,
kind: crate::error::UpgradePublishedSchemaErrorKind::InvalidAttachmentException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_attachment_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_attachment_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpgradePublishedSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::UpgradePublishedSchemaError {
meta: generic,
kind: crate::error::UpgradePublishedSchemaErrorKind::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::UpgradePublishedSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpgradePublishedSchemaError {
meta: generic,
kind: crate::error::UpgradePublishedSchemaErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpgradePublishedSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RetryableConflictException" => crate::error::UpgradePublishedSchemaError {
meta: generic,
kind: crate::error::UpgradePublishedSchemaErrorKind::RetryableConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::retryable_conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_retryable_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpgradePublishedSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::UpgradePublishedSchemaError {
meta: generic,
kind: crate::error::UpgradePublishedSchemaErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpgradePublishedSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpgradePublishedSchemaError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_upgrade_published_schema_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpgradePublishedSchemaOutput,
crate::error::UpgradePublishedSchemaError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::upgrade_published_schema_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_upgrade_published_schema(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpgradePublishedSchemaError::unhandled)?;
output.build()
})
}