#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_node_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::AssociateNodeOutput, crate::error::AssociateNodeError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::AssociateNodeError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::AssociateNodeError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidStateException" => crate::error::AssociateNodeError {
meta: generic,
kind: crate::error::AssociateNodeErrorKind::InvalidStateException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_state_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_state_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AssociateNodeError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::AssociateNodeError {
meta: generic,
kind: crate::error::AssociateNodeErrorKind::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::AssociateNodeError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::AssociateNodeError {
meta: generic,
kind: crate::error::AssociateNodeErrorKind::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::AssociateNodeError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::AssociateNodeError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_node_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::AssociateNodeOutput, crate::error::AssociateNodeError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::associate_node_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_associate_node(
response.body().as_ref(),
output,
)
.map_err(crate::error::AssociateNodeError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_backup_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateBackupOutput, crate::error::CreateBackupError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateBackupError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateBackupError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidStateException" => crate::error::CreateBackupError {
meta: generic,
kind: crate::error::CreateBackupErrorKind::InvalidStateException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_state_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_state_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateBackupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateBackupError {
meta: generic,
kind: crate::error::CreateBackupErrorKind::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::CreateBackupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateBackupError {
meta: generic,
kind: crate::error::CreateBackupErrorKind::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::CreateBackupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::CreateBackupError {
meta: generic,
kind: crate::error::CreateBackupErrorKind::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::CreateBackupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateBackupError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_backup_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateBackupOutput, crate::error::CreateBackupError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_backup_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_backup(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateBackupError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_server_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateServerOutput, crate::error::CreateServerError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateServerError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateServerError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"LimitExceededException" => crate::error::CreateServerError {
meta: generic,
kind: crate::error::CreateServerErrorKind::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::CreateServerError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceAlreadyExistsException" => crate::error::CreateServerError {
meta: generic,
kind: crate::error::CreateServerErrorKind::ResourceAlreadyExistsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::resource_already_exists_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateServerError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateServerError {
meta: generic,
kind: crate::error::CreateServerErrorKind::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::CreateServerError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::CreateServerError {
meta: generic,
kind: crate::error::CreateServerErrorKind::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::CreateServerError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateServerError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_server_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateServerOutput, crate::error::CreateServerError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_server_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_server(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateServerError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_backup_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteBackupOutput, crate::error::DeleteBackupError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteBackupError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteBackupError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidStateException" => crate::error::DeleteBackupError {
meta: generic,
kind: crate::error::DeleteBackupErrorKind::InvalidStateException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_state_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_state_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteBackupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteBackupError {
meta: generic,
kind: crate::error::DeleteBackupErrorKind::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::DeleteBackupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::DeleteBackupError {
meta: generic,
kind: crate::error::DeleteBackupErrorKind::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::DeleteBackupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteBackupError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_backup_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteBackupOutput, crate::error::DeleteBackupError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_backup_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_server_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteServerOutput, crate::error::DeleteServerError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteServerError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteServerError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidStateException" => crate::error::DeleteServerError {
meta: generic,
kind: crate::error::DeleteServerErrorKind::InvalidStateException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_state_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_state_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteServerError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteServerError {
meta: generic,
kind: crate::error::DeleteServerErrorKind::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::DeleteServerError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::DeleteServerError {
meta: generic,
kind: crate::error::DeleteServerErrorKind::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::DeleteServerError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteServerError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_server_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteServerOutput, crate::error::DeleteServerError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_server_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_account_attributes_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeAccountAttributesOutput,
crate::error::DescribeAccountAttributesError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeAccountAttributesError::unhandled)?;
Err(crate::error::DescribeAccountAttributesError::generic(
generic,
))
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_account_attributes_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeAccountAttributesOutput,
crate::error::DescribeAccountAttributesError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_account_attributes_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_account_attributes(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeAccountAttributesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_backups_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeBackupsOutput, crate::error::DescribeBackupsError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeBackupsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeBackupsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidNextTokenException" => crate::error::DescribeBackupsError {
meta: generic,
kind: crate::error::DescribeBackupsErrorKind::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::DescribeBackupsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeBackupsError {
meta: generic,
kind: crate::error::DescribeBackupsErrorKind::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::DescribeBackupsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::DescribeBackupsError {
meta: generic,
kind: crate::error::DescribeBackupsErrorKind::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::DescribeBackupsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeBackupsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_backups_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeBackupsOutput, crate::error::DescribeBackupsError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_backups_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_backups(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeBackupsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_events_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeEventsOutput, crate::error::DescribeEventsError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeEventsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeEventsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidNextTokenException" => crate::error::DescribeEventsError {
meta: generic,
kind: crate::error::DescribeEventsErrorKind::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::DescribeEventsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeEventsError {
meta: generic,
kind: crate::error::DescribeEventsErrorKind::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::DescribeEventsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::DescribeEventsError {
meta: generic,
kind: crate::error::DescribeEventsErrorKind::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::DescribeEventsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeEventsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_events_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeEventsOutput, crate::error::DescribeEventsError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_events_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_events(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeEventsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_node_association_status_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeNodeAssociationStatusOutput,
crate::error::DescribeNodeAssociationStatusError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeNodeAssociationStatusError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeNodeAssociationStatusError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ResourceNotFoundException" => crate::error::DescribeNodeAssociationStatusError {
meta: generic,
kind: crate::error::DescribeNodeAssociationStatusErrorKind::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::DescribeNodeAssociationStatusError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ValidationException" => crate::error::DescribeNodeAssociationStatusError {
meta: generic,
kind: crate::error::DescribeNodeAssociationStatusErrorKind::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::DescribeNodeAssociationStatusError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeNodeAssociationStatusError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_node_association_status_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeNodeAssociationStatusOutput,
crate::error::DescribeNodeAssociationStatusError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_node_association_status_output::Builder::default();
let _ = response;
output =
crate::json_deser::deser_operation_crate_operation_describe_node_association_status(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeNodeAssociationStatusError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_servers_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeServersOutput, crate::error::DescribeServersError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeServersError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeServersError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidNextTokenException" => crate::error::DescribeServersError {
meta: generic,
kind: crate::error::DescribeServersErrorKind::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::DescribeServersError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeServersError {
meta: generic,
kind: crate::error::DescribeServersErrorKind::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::DescribeServersError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::DescribeServersError {
meta: generic,
kind: crate::error::DescribeServersErrorKind::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::DescribeServersError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeServersError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_servers_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeServersOutput, crate::error::DescribeServersError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_servers_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_servers(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeServersError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_node_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DisassociateNodeOutput, crate::error::DisassociateNodeError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DisassociateNodeError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DisassociateNodeError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidStateException" => crate::error::DisassociateNodeError {
meta: generic,
kind: crate::error::DisassociateNodeErrorKind::InvalidStateException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_state_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_state_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DisassociateNodeError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DisassociateNodeError {
meta: generic,
kind: crate::error::DisassociateNodeErrorKind::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::DisassociateNodeError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::DisassociateNodeError {
meta: generic,
kind: crate::error::DisassociateNodeErrorKind::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::DisassociateNodeError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DisassociateNodeError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_node_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DisassociateNodeOutput, crate::error::DisassociateNodeError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::disassociate_node_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_disassociate_node(
response.body().as_ref(),
output,
)
.map_err(crate::error::DisassociateNodeError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_export_server_engine_attribute_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ExportServerEngineAttributeOutput,
crate::error::ExportServerEngineAttributeError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ExportServerEngineAttributeError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ExportServerEngineAttributeError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidStateException" => crate::error::ExportServerEngineAttributeError {
meta: generic,
kind: crate::error::ExportServerEngineAttributeErrorKind::InvalidStateException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_state_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_state_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ExportServerEngineAttributeError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ExportServerEngineAttributeError {
meta: generic,
kind: crate::error::ExportServerEngineAttributeErrorKind::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::ExportServerEngineAttributeError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::ExportServerEngineAttributeError {
meta: generic,
kind: crate::error::ExportServerEngineAttributeErrorKind::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::ExportServerEngineAttributeError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ExportServerEngineAttributeError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_export_server_engine_attribute_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ExportServerEngineAttributeOutput,
crate::error::ExportServerEngineAttributeError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::export_server_engine_attribute_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_export_server_engine_attribute(
response.body().as_ref(),
output,
)
.map_err(crate::error::ExportServerEngineAttributeError::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 {
"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
}),
},
"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_restore_server_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::RestoreServerOutput, crate::error::RestoreServerError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::RestoreServerError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::RestoreServerError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidStateException" => crate::error::RestoreServerError {
meta: generic,
kind: crate::error::RestoreServerErrorKind::InvalidStateException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_state_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_state_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RestoreServerError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::RestoreServerError {
meta: generic,
kind: crate::error::RestoreServerErrorKind::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::RestoreServerError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::RestoreServerError {
meta: generic,
kind: crate::error::RestoreServerErrorKind::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::RestoreServerError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::RestoreServerError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_restore_server_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::RestoreServerOutput, crate::error::RestoreServerError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::restore_server_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_restore_server(
response.body().as_ref(),
output,
)
.map_err(crate::error::RestoreServerError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_maintenance_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StartMaintenanceOutput, crate::error::StartMaintenanceError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StartMaintenanceError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::StartMaintenanceError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidStateException" => crate::error::StartMaintenanceError {
meta: generic,
kind: crate::error::StartMaintenanceErrorKind::InvalidStateException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_state_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_state_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartMaintenanceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::StartMaintenanceError {
meta: generic,
kind: crate::error::StartMaintenanceErrorKind::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::StartMaintenanceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::StartMaintenanceError {
meta: generic,
kind: crate::error::StartMaintenanceErrorKind::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::StartMaintenanceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::StartMaintenanceError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_maintenance_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StartMaintenanceOutput, crate::error::StartMaintenanceError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::start_maintenance_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_start_maintenance(
response.body().as_ref(),
output,
)
.map_err(crate::error::StartMaintenanceError::unhandled)?;
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 {
"InvalidStateException" => crate::error::TagResourceError {
meta: generic,
kind: crate::error::TagResourceErrorKind::InvalidStateException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_state_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_state_exception_json_err(response.body().as_ref(), output).map_err(crate::error::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
}),
},
"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 {
"InvalidStateException" => crate::error::UntagResourceError {
meta: generic,
kind: crate::error::UntagResourceErrorKind::InvalidStateException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_state_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_state_exception_json_err(response.body().as_ref(), output).map_err(crate::error::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
}),
},
"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_server_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateServerOutput, crate::error::UpdateServerError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateServerError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UpdateServerError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidStateException" => crate::error::UpdateServerError {
meta: generic,
kind: crate::error::UpdateServerErrorKind::InvalidStateException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_state_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_state_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateServerError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpdateServerError {
meta: generic,
kind: crate::error::UpdateServerErrorKind::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::UpdateServerError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::UpdateServerError {
meta: generic,
kind: crate::error::UpdateServerErrorKind::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::UpdateServerError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateServerError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_server_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateServerOutput, crate::error::UpdateServerError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_server_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_server(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateServerError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_server_engine_attributes_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateServerEngineAttributesOutput,
crate::error::UpdateServerEngineAttributesError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateServerEngineAttributesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::UpdateServerEngineAttributesError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidStateException" => crate::error::UpdateServerEngineAttributesError {
meta: generic,
kind: crate::error::UpdateServerEngineAttributesErrorKind::InvalidStateException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_state_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_state_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateServerEngineAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpdateServerEngineAttributesError {
meta: generic,
kind: crate::error::UpdateServerEngineAttributesErrorKind::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::UpdateServerEngineAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::UpdateServerEngineAttributesError {
meta: generic,
kind: crate::error::UpdateServerEngineAttributesErrorKind::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::UpdateServerEngineAttributesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateServerEngineAttributesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_server_engine_attributes_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateServerEngineAttributesOutput,
crate::error::UpdateServerEngineAttributesError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_server_engine_attributes_output::Builder::default();
let _ = response;
output =
crate::json_deser::deser_operation_crate_operation_update_server_engine_attributes(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateServerEngineAttributesError::unhandled)?;
output.build()
})
}