#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_encryption_config_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::AssociateEncryptionConfigOutput,
crate::error::AssociateEncryptionConfigError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::AssociateEncryptionConfigError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::AssociateEncryptionConfigError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ClientException" => {
crate::error::AssociateEncryptionConfigError {
meta: generic,
kind: crate::error::AssociateEncryptionConfigErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AssociateEncryptionConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterException" => crate::error::AssociateEncryptionConfigError {
meta: generic,
kind: crate::error::AssociateEncryptionConfigErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AssociateEncryptionConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::AssociateEncryptionConfigError {
meta: generic,
kind: crate::error::AssociateEncryptionConfigErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AssociateEncryptionConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::AssociateEncryptionConfigError {
meta: generic,
kind: crate::error::AssociateEncryptionConfigErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AssociateEncryptionConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::AssociateEncryptionConfigError {
meta: generic,
kind: crate::error::AssociateEncryptionConfigErrorKind::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::AssociateEncryptionConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::AssociateEncryptionConfigError {
meta: generic,
kind: crate::error::AssociateEncryptionConfigErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AssociateEncryptionConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
_ => crate::error::AssociateEncryptionConfigError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_encryption_config_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::AssociateEncryptionConfigOutput,
crate::error::AssociateEncryptionConfigError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::associate_encryption_config_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_associate_encryption_config(
response.body().as_ref(),
output,
)
.map_err(crate::error::AssociateEncryptionConfigError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_identity_provider_config_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::AssociateIdentityProviderConfigOutput,
crate::error::AssociateIdentityProviderConfigError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::AssociateIdentityProviderConfigError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::AssociateIdentityProviderConfigError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ClientException" => {
crate::error::AssociateIdentityProviderConfigError {
meta: generic,
kind: crate::error::AssociateIdentityProviderConfigErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AssociateIdentityProviderConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterException" => crate::error::AssociateIdentityProviderConfigError {
meta: generic,
kind: crate::error::AssociateIdentityProviderConfigErrorKind::InvalidParameterException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AssociateIdentityProviderConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"InvalidRequestException" => crate::error::AssociateIdentityProviderConfigError {
meta: generic,
kind: crate::error::AssociateIdentityProviderConfigErrorKind::InvalidRequestException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AssociateIdentityProviderConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ResourceInUseException" => crate::error::AssociateIdentityProviderConfigError {
meta: generic,
kind: crate::error::AssociateIdentityProviderConfigErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AssociateIdentityProviderConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::AssociateIdentityProviderConfigError {
meta: generic,
kind: crate::error::AssociateIdentityProviderConfigErrorKind::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::AssociateIdentityProviderConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ServerException" => {
crate::error::AssociateIdentityProviderConfigError {
meta: generic,
kind: crate::error::AssociateIdentityProviderConfigErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AssociateIdentityProviderConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
_ => crate::error::AssociateIdentityProviderConfigError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_identity_provider_config_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::AssociateIdentityProviderConfigOutput,
crate::error::AssociateIdentityProviderConfigError,
> {
Ok({
#[allow(unused_mut)]
let mut output =
crate::output::associate_identity_provider_config_output::Builder::default();
let _ = response;
output =
crate::json_deser::deser_operation_crate_operation_associate_identity_provider_config(
response.body().as_ref(),
output,
)
.map_err(crate::error::AssociateIdentityProviderConfigError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_addon_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateAddonOutput, crate::error::CreateAddonError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateAddonError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateAddonError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ClientException" => {
crate::error::CreateAddonError {
meta: generic,
kind: crate::error::CreateAddonErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateAddonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterException" => crate::error::CreateAddonError {
meta: generic,
kind: crate::error::CreateAddonErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateAddonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::CreateAddonError {
meta: generic,
kind: crate::error::CreateAddonErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateAddonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::CreateAddonError {
meta: generic,
kind: crate::error::CreateAddonErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateAddonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateAddonError {
meta: generic,
kind: crate::error::CreateAddonErrorKind::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::CreateAddonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::CreateAddonError {
meta: generic,
kind: crate::error::CreateAddonErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateAddonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
_ => crate::error::CreateAddonError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_addon_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateAddonOutput, crate::error::CreateAddonError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_addon_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_addon(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateAddonError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_cluster_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateClusterOutput, crate::error::CreateClusterError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateClusterError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateClusterError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ClientException" => {
crate::error::CreateClusterError {
meta: generic,
kind: crate::error::CreateClusterErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterException" => crate::error::CreateClusterError {
meta: generic,
kind: crate::error::CreateClusterErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::CreateClusterError {
meta: generic,
kind: crate::error::CreateClusterErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceLimitExceededException" => crate::error::CreateClusterError {
meta: generic,
kind: crate::error::CreateClusterErrorKind::ResourceLimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::resource_limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::CreateClusterError {
meta: generic,
kind: crate::error::CreateClusterErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ServiceUnavailableException" => crate::error::CreateClusterError {
meta: generic,
kind: crate::error::CreateClusterErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"UnsupportedAvailabilityZoneException" => crate::error::CreateClusterError {
meta: generic,
kind: crate::error::CreateClusterErrorKind::UnsupportedAvailabilityZoneException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::unsupported_availability_zone_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_unsupported_availability_zone_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateClusterError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_cluster_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateClusterOutput, crate::error::CreateClusterError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_cluster_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_cluster(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateClusterError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_fargate_profile_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateFargateProfileOutput,
crate::error::CreateFargateProfileError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateFargateProfileError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateFargateProfileError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ClientException" => {
crate::error::CreateFargateProfileError {
meta: generic,
kind: crate::error::CreateFargateProfileErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateFargateProfileError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterException" => crate::error::CreateFargateProfileError {
meta: generic,
kind: crate::error::CreateFargateProfileErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateFargateProfileError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::CreateFargateProfileError {
meta: generic,
kind: crate::error::CreateFargateProfileErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateFargateProfileError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceLimitExceededException" => crate::error::CreateFargateProfileError {
meta: generic,
kind: crate::error::CreateFargateProfileErrorKind::ResourceLimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::resource_limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateFargateProfileError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::CreateFargateProfileError {
meta: generic,
kind: crate::error::CreateFargateProfileErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateFargateProfileError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"UnsupportedAvailabilityZoneException" => crate::error::CreateFargateProfileError {
meta: generic,
kind: crate::error::CreateFargateProfileErrorKind::UnsupportedAvailabilityZoneException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::unsupported_availability_zone_exception::Builder::default(
);
let _ = response;
output = crate::json_deser::deser_structure_crate_error_unsupported_availability_zone_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateFargateProfileError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
_ => crate::error::CreateFargateProfileError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_fargate_profile_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateFargateProfileOutput,
crate::error::CreateFargateProfileError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_fargate_profile_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_fargate_profile(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateFargateProfileError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_nodegroup_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateNodegroupOutput, crate::error::CreateNodegroupError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateNodegroupError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateNodegroupError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ClientException" => {
crate::error::CreateNodegroupError {
meta: generic,
kind: crate::error::CreateNodegroupErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateNodegroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterException" => crate::error::CreateNodegroupError {
meta: generic,
kind: crate::error::CreateNodegroupErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateNodegroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::CreateNodegroupError {
meta: generic,
kind: crate::error::CreateNodegroupErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateNodegroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::CreateNodegroupError {
meta: generic,
kind: crate::error::CreateNodegroupErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateNodegroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceLimitExceededException" => crate::error::CreateNodegroupError {
meta: generic,
kind: crate::error::CreateNodegroupErrorKind::ResourceLimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::resource_limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateNodegroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::CreateNodegroupError {
meta: generic,
kind: crate::error::CreateNodegroupErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateNodegroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ServiceUnavailableException" => crate::error::CreateNodegroupError {
meta: generic,
kind: crate::error::CreateNodegroupErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateNodegroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateNodegroupError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_nodegroup_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateNodegroupOutput, crate::error::CreateNodegroupError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_nodegroup_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_nodegroup(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateNodegroupError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_addon_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteAddonOutput, crate::error::DeleteAddonError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteAddonError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteAddonError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ClientException" => {
crate::error::DeleteAddonError {
meta: generic,
kind: crate::error::DeleteAddonErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteAddonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterException" => crate::error::DeleteAddonError {
meta: generic,
kind: crate::error::DeleteAddonErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteAddonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::DeleteAddonError {
meta: generic,
kind: crate::error::DeleteAddonErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteAddonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteAddonError {
meta: generic,
kind: crate::error::DeleteAddonErrorKind::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::DeleteAddonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::DeleteAddonError {
meta: generic,
kind: crate::error::DeleteAddonErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteAddonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
_ => crate::error::DeleteAddonError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_addon_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteAddonOutput, crate::error::DeleteAddonError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_addon_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_delete_addon(
response.body().as_ref(),
output,
)
.map_err(crate::error::DeleteAddonError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_cluster_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteClusterOutput, crate::error::DeleteClusterError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteClusterError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteClusterError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ClientException" => {
crate::error::DeleteClusterError {
meta: generic,
kind: crate::error::DeleteClusterErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ResourceInUseException" => crate::error::DeleteClusterError {
meta: generic,
kind: crate::error::DeleteClusterErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteClusterError {
meta: generic,
kind: crate::error::DeleteClusterErrorKind::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::DeleteClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::DeleteClusterError {
meta: generic,
kind: crate::error::DeleteClusterErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ServiceUnavailableException" => crate::error::DeleteClusterError {
meta: generic,
kind: crate::error::DeleteClusterErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteClusterError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_cluster_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteClusterOutput, crate::error::DeleteClusterError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_cluster_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_delete_cluster(
response.body().as_ref(),
output,
)
.map_err(crate::error::DeleteClusterError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_fargate_profile_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteFargateProfileOutput,
crate::error::DeleteFargateProfileError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteFargateProfileError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteFargateProfileError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ClientException" => {
crate::error::DeleteFargateProfileError {
meta: generic,
kind: crate::error::DeleteFargateProfileErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteFargateProfileError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterException" => crate::error::DeleteFargateProfileError {
meta: generic,
kind: crate::error::DeleteFargateProfileErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteFargateProfileError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteFargateProfileError {
meta: generic,
kind: crate::error::DeleteFargateProfileErrorKind::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::DeleteFargateProfileError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::DeleteFargateProfileError {
meta: generic,
kind: crate::error::DeleteFargateProfileErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteFargateProfileError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
_ => crate::error::DeleteFargateProfileError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_fargate_profile_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteFargateProfileOutput,
crate::error::DeleteFargateProfileError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_fargate_profile_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_delete_fargate_profile(
response.body().as_ref(),
output,
)
.map_err(crate::error::DeleteFargateProfileError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_nodegroup_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteNodegroupOutput, crate::error::DeleteNodegroupError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteNodegroupError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteNodegroupError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ClientException" => {
crate::error::DeleteNodegroupError {
meta: generic,
kind: crate::error::DeleteNodegroupErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteNodegroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterException" => crate::error::DeleteNodegroupError {
meta: generic,
kind: crate::error::DeleteNodegroupErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteNodegroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::DeleteNodegroupError {
meta: generic,
kind: crate::error::DeleteNodegroupErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteNodegroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteNodegroupError {
meta: generic,
kind: crate::error::DeleteNodegroupErrorKind::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::DeleteNodegroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::DeleteNodegroupError {
meta: generic,
kind: crate::error::DeleteNodegroupErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteNodegroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ServiceUnavailableException" => crate::error::DeleteNodegroupError {
meta: generic,
kind: crate::error::DeleteNodegroupErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteNodegroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteNodegroupError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_nodegroup_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteNodegroupOutput, crate::error::DeleteNodegroupError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_nodegroup_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_delete_nodegroup(
response.body().as_ref(),
output,
)
.map_err(crate::error::DeleteNodegroupError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_deregister_cluster_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeregisterClusterOutput, crate::error::DeregisterClusterError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeregisterClusterError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeregisterClusterError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::DeregisterClusterError {
meta: generic,
kind: crate::error::DeregisterClusterErrorKind::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::DeregisterClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ClientException" => {
crate::error::DeregisterClusterError {
meta: generic,
kind: crate::error::DeregisterClusterErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeregisterClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ResourceInUseException" => crate::error::DeregisterClusterError {
meta: generic,
kind: crate::error::DeregisterClusterErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeregisterClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeregisterClusterError {
meta: generic,
kind: crate::error::DeregisterClusterErrorKind::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::DeregisterClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::DeregisterClusterError {
meta: generic,
kind: crate::error::DeregisterClusterErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeregisterClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ServiceUnavailableException" => crate::error::DeregisterClusterError {
meta: generic,
kind: crate::error::DeregisterClusterErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeregisterClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeregisterClusterError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_deregister_cluster_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeregisterClusterOutput, crate::error::DeregisterClusterError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::deregister_cluster_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_deregister_cluster(
response.body().as_ref(),
output,
)
.map_err(crate::error::DeregisterClusterError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_addon_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeAddonOutput, crate::error::DescribeAddonError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeAddonError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeAddonError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ClientException" => {
crate::error::DescribeAddonError {
meta: generic,
kind: crate::error::DescribeAddonErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeAddonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterException" => crate::error::DescribeAddonError {
meta: generic,
kind: crate::error::DescribeAddonErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeAddonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::DescribeAddonError {
meta: generic,
kind: crate::error::DescribeAddonErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeAddonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeAddonError {
meta: generic,
kind: crate::error::DescribeAddonErrorKind::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::DescribeAddonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::DescribeAddonError {
meta: generic,
kind: crate::error::DescribeAddonErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeAddonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
_ => crate::error::DescribeAddonError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_addon_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeAddonOutput, crate::error::DescribeAddonError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_addon_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_addon(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeAddonError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_addon_configuration_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeAddonConfigurationOutput,
crate::error::DescribeAddonConfigurationError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeAddonConfigurationError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeAddonConfigurationError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterException" => crate::error::DescribeAddonConfigurationError {
meta: generic,
kind: crate::error::DescribeAddonConfigurationErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeAddonConfigurationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeAddonConfigurationError {
meta: generic,
kind: crate::error::DescribeAddonConfigurationErrorKind::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::DescribeAddonConfigurationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::DescribeAddonConfigurationError {
meta: generic,
kind: crate::error::DescribeAddonConfigurationErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeAddonConfigurationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
_ => crate::error::DescribeAddonConfigurationError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_addon_configuration_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeAddonConfigurationOutput,
crate::error::DescribeAddonConfigurationError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_addon_configuration_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_addon_configuration(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeAddonConfigurationError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_addon_versions_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeAddonVersionsOutput,
crate::error::DescribeAddonVersionsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeAddonVersionsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeAddonVersionsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterException" => crate::error::DescribeAddonVersionsError {
meta: generic,
kind: crate::error::DescribeAddonVersionsErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeAddonVersionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeAddonVersionsError {
meta: generic,
kind: crate::error::DescribeAddonVersionsErrorKind::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::DescribeAddonVersionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::DescribeAddonVersionsError {
meta: generic,
kind: crate::error::DescribeAddonVersionsErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeAddonVersionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
_ => crate::error::DescribeAddonVersionsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_addon_versions_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeAddonVersionsOutput,
crate::error::DescribeAddonVersionsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_addon_versions_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_addon_versions(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeAddonVersionsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_cluster_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeClusterOutput, crate::error::DescribeClusterError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeClusterError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeClusterError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ClientException" => {
crate::error::DescribeClusterError {
meta: generic,
kind: crate::error::DescribeClusterErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ResourceNotFoundException" => crate::error::DescribeClusterError {
meta: generic,
kind: crate::error::DescribeClusterErrorKind::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::DescribeClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::DescribeClusterError {
meta: generic,
kind: crate::error::DescribeClusterErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ServiceUnavailableException" => crate::error::DescribeClusterError {
meta: generic,
kind: crate::error::DescribeClusterErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeClusterError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_cluster_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeClusterOutput, crate::error::DescribeClusterError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_cluster_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_cluster(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeClusterError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_fargate_profile_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeFargateProfileOutput,
crate::error::DescribeFargateProfileError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeFargateProfileError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeFargateProfileError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ClientException" => {
crate::error::DescribeFargateProfileError {
meta: generic,
kind: crate::error::DescribeFargateProfileErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeFargateProfileError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterException" => crate::error::DescribeFargateProfileError {
meta: generic,
kind: crate::error::DescribeFargateProfileErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeFargateProfileError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeFargateProfileError {
meta: generic,
kind: crate::error::DescribeFargateProfileErrorKind::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::DescribeFargateProfileError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::DescribeFargateProfileError {
meta: generic,
kind: crate::error::DescribeFargateProfileErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeFargateProfileError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
_ => crate::error::DescribeFargateProfileError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_fargate_profile_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeFargateProfileOutput,
crate::error::DescribeFargateProfileError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_fargate_profile_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_fargate_profile(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeFargateProfileError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_identity_provider_config_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeIdentityProviderConfigOutput,
crate::error::DescribeIdentityProviderConfigError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeIdentityProviderConfigError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeIdentityProviderConfigError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ClientException" => {
crate::error::DescribeIdentityProviderConfigError {
meta: generic,
kind: crate::error::DescribeIdentityProviderConfigErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeIdentityProviderConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterException" => crate::error::DescribeIdentityProviderConfigError {
meta: generic,
kind: crate::error::DescribeIdentityProviderConfigErrorKind::InvalidParameterException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeIdentityProviderConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ResourceNotFoundException" => crate::error::DescribeIdentityProviderConfigError {
meta: generic,
kind: crate::error::DescribeIdentityProviderConfigErrorKind::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::DescribeIdentityProviderConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ServerException" => {
crate::error::DescribeIdentityProviderConfigError {
meta: generic,
kind: crate::error::DescribeIdentityProviderConfigErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeIdentityProviderConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ServiceUnavailableException" => crate::error::DescribeIdentityProviderConfigError {
meta: generic,
kind:
crate::error::DescribeIdentityProviderConfigErrorKind::ServiceUnavailableException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeIdentityProviderConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
_ => crate::error::DescribeIdentityProviderConfigError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_identity_provider_config_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeIdentityProviderConfigOutput,
crate::error::DescribeIdentityProviderConfigError,
> {
Ok({
#[allow(unused_mut)]
let mut output =
crate::output::describe_identity_provider_config_output::Builder::default();
let _ = response;
output =
crate::json_deser::deser_operation_crate_operation_describe_identity_provider_config(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeIdentityProviderConfigError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_nodegroup_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeNodegroupOutput, crate::error::DescribeNodegroupError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeNodegroupError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeNodegroupError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ClientException" => {
crate::error::DescribeNodegroupError {
meta: generic,
kind: crate::error::DescribeNodegroupErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeNodegroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterException" => crate::error::DescribeNodegroupError {
meta: generic,
kind: crate::error::DescribeNodegroupErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeNodegroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeNodegroupError {
meta: generic,
kind: crate::error::DescribeNodegroupErrorKind::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::DescribeNodegroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::DescribeNodegroupError {
meta: generic,
kind: crate::error::DescribeNodegroupErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeNodegroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ServiceUnavailableException" => crate::error::DescribeNodegroupError {
meta: generic,
kind: crate::error::DescribeNodegroupErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeNodegroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeNodegroupError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_nodegroup_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeNodegroupOutput, crate::error::DescribeNodegroupError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_nodegroup_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_nodegroup(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeNodegroupError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_update_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeUpdateOutput, crate::error::DescribeUpdateError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeUpdateError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeUpdateError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ClientException" => {
crate::error::DescribeUpdateError {
meta: generic,
kind: crate::error::DescribeUpdateErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeUpdateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterException" => crate::error::DescribeUpdateError {
meta: generic,
kind: crate::error::DescribeUpdateErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeUpdateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeUpdateError {
meta: generic,
kind: crate::error::DescribeUpdateErrorKind::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::DescribeUpdateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::DescribeUpdateError {
meta: generic,
kind: crate::error::DescribeUpdateErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeUpdateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
_ => crate::error::DescribeUpdateError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_update_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeUpdateOutput, crate::error::DescribeUpdateError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_update_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_update(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeUpdateError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_identity_provider_config_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DisassociateIdentityProviderConfigOutput,
crate::error::DisassociateIdentityProviderConfigError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DisassociateIdentityProviderConfigError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DisassociateIdentityProviderConfigError::unhandled(generic))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ClientException" => {
crate::error::DisassociateIdentityProviderConfigError {
meta: generic,
kind: crate::error::DisassociateIdentityProviderConfigErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DisassociateIdentityProviderConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterException" => crate::error::DisassociateIdentityProviderConfigError {
meta: generic,
kind:
crate::error::DisassociateIdentityProviderConfigErrorKind::InvalidParameterException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DisassociateIdentityProviderConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"InvalidRequestException" => crate::error::DisassociateIdentityProviderConfigError {
meta: generic,
kind:
crate::error::DisassociateIdentityProviderConfigErrorKind::InvalidRequestException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DisassociateIdentityProviderConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ResourceInUseException" => crate::error::DisassociateIdentityProviderConfigError {
meta: generic,
kind: crate::error::DisassociateIdentityProviderConfigErrorKind::ResourceInUseException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DisassociateIdentityProviderConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ResourceNotFoundException" => crate::error::DisassociateIdentityProviderConfigError {
meta: generic,
kind:
crate::error::DisassociateIdentityProviderConfigErrorKind::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::DisassociateIdentityProviderConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ServerException" => {
crate::error::DisassociateIdentityProviderConfigError {
meta: generic,
kind: crate::error::DisassociateIdentityProviderConfigErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DisassociateIdentityProviderConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
_ => crate::error::DisassociateIdentityProviderConfigError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_identity_provider_config_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DisassociateIdentityProviderConfigOutput,
crate::error::DisassociateIdentityProviderConfigError,
> {
Ok({
#[allow(unused_mut)]
let mut output =
crate::output::disassociate_identity_provider_config_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_disassociate_identity_provider_config(response.body().as_ref(), output).map_err(crate::error::DisassociateIdentityProviderConfigError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_addons_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListAddonsOutput, crate::error::ListAddonsError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListAddonsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListAddonsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ClientException" => {
crate::error::ListAddonsError {
meta: generic,
kind: crate::error::ListAddonsErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAddonsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterException" => crate::error::ListAddonsError {
meta: generic,
kind: crate::error::ListAddonsErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAddonsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::ListAddonsError {
meta: generic,
kind: crate::error::ListAddonsErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAddonsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListAddonsError {
meta: generic,
kind: crate::error::ListAddonsErrorKind::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::ListAddonsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::ListAddonsError {
meta: generic,
kind: crate::error::ListAddonsErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAddonsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
_ => crate::error::ListAddonsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_addons_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListAddonsOutput, crate::error::ListAddonsError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_addons_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_addons(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListAddonsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_clusters_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListClustersOutput, crate::error::ListClustersError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListClustersError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListClustersError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ClientException" => {
crate::error::ListClustersError {
meta: generic,
kind: crate::error::ListClustersErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListClustersError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterException" => crate::error::ListClustersError {
meta: generic,
kind: crate::error::ListClustersErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListClustersError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::ListClustersError {
meta: generic,
kind: crate::error::ListClustersErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListClustersError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ServiceUnavailableException" => crate::error::ListClustersError {
meta: generic,
kind: crate::error::ListClustersErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListClustersError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListClustersError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_clusters_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListClustersOutput, crate::error::ListClustersError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_clusters_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_clusters(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListClustersError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_fargate_profiles_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListFargateProfilesOutput,
crate::error::ListFargateProfilesError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListFargateProfilesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListFargateProfilesError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ClientException" => {
crate::error::ListFargateProfilesError {
meta: generic,
kind: crate::error::ListFargateProfilesErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListFargateProfilesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterException" => crate::error::ListFargateProfilesError {
meta: generic,
kind: crate::error::ListFargateProfilesErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListFargateProfilesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListFargateProfilesError {
meta: generic,
kind: crate::error::ListFargateProfilesErrorKind::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::ListFargateProfilesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::ListFargateProfilesError {
meta: generic,
kind: crate::error::ListFargateProfilesErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListFargateProfilesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
_ => crate::error::ListFargateProfilesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_fargate_profiles_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListFargateProfilesOutput,
crate::error::ListFargateProfilesError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_fargate_profiles_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_fargate_profiles(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListFargateProfilesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_identity_provider_configs_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListIdentityProviderConfigsOutput,
crate::error::ListIdentityProviderConfigsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListIdentityProviderConfigsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListIdentityProviderConfigsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ClientException" => {
crate::error::ListIdentityProviderConfigsError {
meta: generic,
kind: crate::error::ListIdentityProviderConfigsErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListIdentityProviderConfigsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterException" => crate::error::ListIdentityProviderConfigsError {
meta: generic,
kind: crate::error::ListIdentityProviderConfigsErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListIdentityProviderConfigsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListIdentityProviderConfigsError {
meta: generic,
kind: crate::error::ListIdentityProviderConfigsErrorKind::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::ListIdentityProviderConfigsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::ListIdentityProviderConfigsError {
meta: generic,
kind: crate::error::ListIdentityProviderConfigsErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListIdentityProviderConfigsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ServiceUnavailableException" => crate::error::ListIdentityProviderConfigsError {
meta: generic,
kind: crate::error::ListIdentityProviderConfigsErrorKind::ServiceUnavailableException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListIdentityProviderConfigsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
_ => crate::error::ListIdentityProviderConfigsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_identity_provider_configs_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListIdentityProviderConfigsOutput,
crate::error::ListIdentityProviderConfigsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_identity_provider_configs_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_identity_provider_configs(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListIdentityProviderConfigsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_nodegroups_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListNodegroupsOutput, crate::error::ListNodegroupsError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListNodegroupsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListNodegroupsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ClientException" => {
crate::error::ListNodegroupsError {
meta: generic,
kind: crate::error::ListNodegroupsErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListNodegroupsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterException" => crate::error::ListNodegroupsError {
meta: generic,
kind: crate::error::ListNodegroupsErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListNodegroupsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListNodegroupsError {
meta: generic,
kind: crate::error::ListNodegroupsErrorKind::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::ListNodegroupsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::ListNodegroupsError {
meta: generic,
kind: crate::error::ListNodegroupsErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListNodegroupsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ServiceUnavailableException" => crate::error::ListNodegroupsError {
meta: generic,
kind: crate::error::ListNodegroupsErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListNodegroupsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListNodegroupsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_nodegroups_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListNodegroupsOutput, crate::error::ListNodegroupsError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_nodegroups_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_nodegroups(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListNodegroupsError::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 {
"BadRequestException" => crate::error::ListTagsForResourceError {
meta: generic,
kind: crate::error::ListTagsForResourceErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_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
}),
},
"NotFoundException" => crate::error::ListTagsForResourceError {
meta: generic,
kind: crate::error::ListTagsForResourceErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_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
}),
},
_ => 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_updates_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListUpdatesOutput, crate::error::ListUpdatesError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListUpdatesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListUpdatesError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ClientException" => {
crate::error::ListUpdatesError {
meta: generic,
kind: crate::error::ListUpdatesErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListUpdatesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterException" => crate::error::ListUpdatesError {
meta: generic,
kind: crate::error::ListUpdatesErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListUpdatesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListUpdatesError {
meta: generic,
kind: crate::error::ListUpdatesErrorKind::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::ListUpdatesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::ListUpdatesError {
meta: generic,
kind: crate::error::ListUpdatesErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListUpdatesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
_ => crate::error::ListUpdatesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_updates_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListUpdatesOutput, crate::error::ListUpdatesError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_updates_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_updates(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListUpdatesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_register_cluster_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::RegisterClusterOutput, crate::error::RegisterClusterError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::RegisterClusterError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::RegisterClusterError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::RegisterClusterError {
meta: generic,
kind: crate::error::RegisterClusterErrorKind::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::RegisterClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ClientException" => {
crate::error::RegisterClusterError {
meta: generic,
kind: crate::error::RegisterClusterErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RegisterClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterException" => crate::error::RegisterClusterError {
meta: generic,
kind: crate::error::RegisterClusterErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RegisterClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::RegisterClusterError {
meta: generic,
kind: crate::error::RegisterClusterErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RegisterClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceLimitExceededException" => crate::error::RegisterClusterError {
meta: generic,
kind: crate::error::RegisterClusterErrorKind::ResourceLimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::resource_limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RegisterClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourcePropagationDelayException" => crate::error::RegisterClusterError {
meta: generic,
kind: crate::error::RegisterClusterErrorKind::ResourcePropagationDelayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::resource_propagation_delay_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_propagation_delay_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RegisterClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::RegisterClusterError {
meta: generic,
kind: crate::error::RegisterClusterErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RegisterClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ServiceUnavailableException" => crate::error::RegisterClusterError {
meta: generic,
kind: crate::error::RegisterClusterErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RegisterClusterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::RegisterClusterError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_register_cluster_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::RegisterClusterOutput, crate::error::RegisterClusterError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::register_cluster_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_register_cluster(
response.body().as_ref(),
output,
)
.map_err(crate::error::RegisterClusterError::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 {
"BadRequestException" => crate::error::TagResourceError {
meta: generic,
kind: crate::error::TagResourceErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_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
}),
},
"NotFoundException" => crate::error::TagResourceError {
meta: generic,
kind: crate::error::TagResourceErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_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
}),
},
_ => 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 {
"BadRequestException" => crate::error::UntagResourceError {
meta: generic,
kind: crate::error::UntagResourceErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_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
}),
},
"NotFoundException" => crate::error::UntagResourceError {
meta: generic,
kind: crate::error::UntagResourceErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_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
}),
},
_ => 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_addon_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateAddonOutput, crate::error::UpdateAddonError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateAddonError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UpdateAddonError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ClientException" => {
crate::error::UpdateAddonError {
meta: generic,
kind: crate::error::UpdateAddonErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateAddonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterException" => crate::error::UpdateAddonError {
meta: generic,
kind: crate::error::UpdateAddonErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateAddonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::UpdateAddonError {
meta: generic,
kind: crate::error::UpdateAddonErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateAddonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::UpdateAddonError {
meta: generic,
kind: crate::error::UpdateAddonErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateAddonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpdateAddonError {
meta: generic,
kind: crate::error::UpdateAddonErrorKind::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::UpdateAddonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::UpdateAddonError {
meta: generic,
kind: crate::error::UpdateAddonErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateAddonError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
_ => crate::error::UpdateAddonError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_addon_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateAddonOutput, crate::error::UpdateAddonError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_addon_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_addon(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateAddonError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_cluster_config_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateClusterConfigOutput,
crate::error::UpdateClusterConfigError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateClusterConfigError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UpdateClusterConfigError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ClientException" => {
crate::error::UpdateClusterConfigError {
meta: generic,
kind: crate::error::UpdateClusterConfigErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateClusterConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterException" => crate::error::UpdateClusterConfigError {
meta: generic,
kind: crate::error::UpdateClusterConfigErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateClusterConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::UpdateClusterConfigError {
meta: generic,
kind: crate::error::UpdateClusterConfigErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateClusterConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::UpdateClusterConfigError {
meta: generic,
kind: crate::error::UpdateClusterConfigErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateClusterConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpdateClusterConfigError {
meta: generic,
kind: crate::error::UpdateClusterConfigErrorKind::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::UpdateClusterConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::UpdateClusterConfigError {
meta: generic,
kind: crate::error::UpdateClusterConfigErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateClusterConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
_ => crate::error::UpdateClusterConfigError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_cluster_config_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateClusterConfigOutput,
crate::error::UpdateClusterConfigError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_cluster_config_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_cluster_config(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateClusterConfigError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_cluster_version_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateClusterVersionOutput,
crate::error::UpdateClusterVersionError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateClusterVersionError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UpdateClusterVersionError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ClientException" => {
crate::error::UpdateClusterVersionError {
meta: generic,
kind: crate::error::UpdateClusterVersionErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateClusterVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterException" => crate::error::UpdateClusterVersionError {
meta: generic,
kind: crate::error::UpdateClusterVersionErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateClusterVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::UpdateClusterVersionError {
meta: generic,
kind: crate::error::UpdateClusterVersionErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateClusterVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::UpdateClusterVersionError {
meta: generic,
kind: crate::error::UpdateClusterVersionErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateClusterVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpdateClusterVersionError {
meta: generic,
kind: crate::error::UpdateClusterVersionErrorKind::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::UpdateClusterVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::UpdateClusterVersionError {
meta: generic,
kind: crate::error::UpdateClusterVersionErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateClusterVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
_ => crate::error::UpdateClusterVersionError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_cluster_version_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateClusterVersionOutput,
crate::error::UpdateClusterVersionError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_cluster_version_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_cluster_version(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateClusterVersionError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_nodegroup_config_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateNodegroupConfigOutput,
crate::error::UpdateNodegroupConfigError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateNodegroupConfigError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UpdateNodegroupConfigError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ClientException" => {
crate::error::UpdateNodegroupConfigError {
meta: generic,
kind: crate::error::UpdateNodegroupConfigErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateNodegroupConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterException" => crate::error::UpdateNodegroupConfigError {
meta: generic,
kind: crate::error::UpdateNodegroupConfigErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateNodegroupConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::UpdateNodegroupConfigError {
meta: generic,
kind: crate::error::UpdateNodegroupConfigErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateNodegroupConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::UpdateNodegroupConfigError {
meta: generic,
kind: crate::error::UpdateNodegroupConfigErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateNodegroupConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpdateNodegroupConfigError {
meta: generic,
kind: crate::error::UpdateNodegroupConfigErrorKind::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::UpdateNodegroupConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::UpdateNodegroupConfigError {
meta: generic,
kind: crate::error::UpdateNodegroupConfigErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateNodegroupConfigError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
_ => crate::error::UpdateNodegroupConfigError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_nodegroup_config_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateNodegroupConfigOutput,
crate::error::UpdateNodegroupConfigError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_nodegroup_config_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_nodegroup_config(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateNodegroupConfigError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_nodegroup_version_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateNodegroupVersionOutput,
crate::error::UpdateNodegroupVersionError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateNodegroupVersionError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::UpdateNodegroupVersionError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ClientException" => {
crate::error::UpdateNodegroupVersionError {
meta: generic,
kind: crate::error::UpdateNodegroupVersionErrorKind::ClientException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::client_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_client_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateNodegroupVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterException" => crate::error::UpdateNodegroupVersionError {
meta: generic,
kind: crate::error::UpdateNodegroupVersionErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateNodegroupVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::UpdateNodegroupVersionError {
meta: generic,
kind: crate::error::UpdateNodegroupVersionErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateNodegroupVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::UpdateNodegroupVersionError {
meta: generic,
kind: crate::error::UpdateNodegroupVersionErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateNodegroupVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpdateNodegroupVersionError {
meta: generic,
kind: crate::error::UpdateNodegroupVersionErrorKind::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::UpdateNodegroupVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServerException" => {
crate::error::UpdateNodegroupVersionError {
meta: generic,
kind: crate::error::UpdateNodegroupVersionErrorKind::ServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateNodegroupVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
_ => crate::error::UpdateNodegroupVersionError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_nodegroup_version_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateNodegroupVersionOutput,
crate::error::UpdateNodegroupVersionError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_nodegroup_version_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_nodegroup_version(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateNodegroupVersionError::unhandled)?;
output.build()
})
}