#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_application_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateApplicationOutput, crate::error::CreateApplicationError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateApplicationError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateApplicationError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::CreateApplicationError {
meta: generic,
kind: crate::error::CreateApplicationErrorKind::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::CreateApplicationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::CreateApplicationError {
meta: generic,
kind: crate::error::CreateApplicationErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateApplicationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateApplicationError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_application_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateApplicationOutput, crate::error::CreateApplicationError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_application_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_application(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateApplicationError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_configuration_profile_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateConfigurationProfileOutput,
crate::error::CreateConfigurationProfileError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateConfigurationProfileError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::CreateConfigurationProfileError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::CreateConfigurationProfileError {
meta: generic,
kind: crate::error::CreateConfigurationProfileErrorKind::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::CreateConfigurationProfileError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::CreateConfigurationProfileError {
meta: generic,
kind: crate::error::CreateConfigurationProfileErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateConfigurationProfileError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateConfigurationProfileError {
meta: generic,
kind: crate::error::CreateConfigurationProfileErrorKind::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::CreateConfigurationProfileError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateConfigurationProfileError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_configuration_profile_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateConfigurationProfileOutput,
crate::error::CreateConfigurationProfileError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_configuration_profile_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_configuration_profile(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateConfigurationProfileError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_deployment_strategy_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateDeploymentStrategyOutput,
crate::error::CreateDeploymentStrategyError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateDeploymentStrategyError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::CreateDeploymentStrategyError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::CreateDeploymentStrategyError {
meta: generic,
kind: crate::error::CreateDeploymentStrategyErrorKind::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::CreateDeploymentStrategyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::CreateDeploymentStrategyError {
meta: generic,
kind: crate::error::CreateDeploymentStrategyErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentStrategyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateDeploymentStrategyError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_deployment_strategy_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateDeploymentStrategyOutput,
crate::error::CreateDeploymentStrategyError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_deployment_strategy_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_deployment_strategy(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateDeploymentStrategyError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_environment_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateEnvironmentOutput, crate::error::CreateEnvironmentError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateEnvironmentError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateEnvironmentError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::CreateEnvironmentError {
meta: generic,
kind: crate::error::CreateEnvironmentErrorKind::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::CreateEnvironmentError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::CreateEnvironmentError {
meta: generic,
kind: crate::error::CreateEnvironmentErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateEnvironmentError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateEnvironmentError {
meta: generic,
kind: crate::error::CreateEnvironmentErrorKind::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::CreateEnvironmentError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateEnvironmentError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_environment_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateEnvironmentOutput, crate::error::CreateEnvironmentError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_environment_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_environment(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateEnvironmentError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_extension_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateExtensionOutput, crate::error::CreateExtensionError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateExtensionError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateExtensionError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::CreateExtensionError {
meta: generic,
kind: crate::error::CreateExtensionErrorKind::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::CreateExtensionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::CreateExtensionError {
meta: generic,
kind: crate::error::CreateExtensionErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateExtensionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InternalServerException" => crate::error::CreateExtensionError {
meta: generic,
kind: crate::error::CreateExtensionErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateExtensionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceQuotaExceededException" => crate::error::CreateExtensionError {
meta: generic,
kind: crate::error::CreateExtensionErrorKind::ServiceQuotaExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_quota_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_quota_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateExtensionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateExtensionError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_extension_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateExtensionOutput, crate::error::CreateExtensionError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_extension_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_extension(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateExtensionError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_extension_association_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateExtensionAssociationOutput,
crate::error::CreateExtensionAssociationError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateExtensionAssociationError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::CreateExtensionAssociationError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::CreateExtensionAssociationError {
meta: generic,
kind: crate::error::CreateExtensionAssociationErrorKind::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::CreateExtensionAssociationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::CreateExtensionAssociationError {
meta: generic,
kind: crate::error::CreateExtensionAssociationErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateExtensionAssociationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateExtensionAssociationError {
meta: generic,
kind: crate::error::CreateExtensionAssociationErrorKind::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::CreateExtensionAssociationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceQuotaExceededException" => crate::error::CreateExtensionAssociationError {
meta: generic,
kind: crate::error::CreateExtensionAssociationErrorKind::ServiceQuotaExceededException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_quota_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_quota_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateExtensionAssociationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
_ => crate::error::CreateExtensionAssociationError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_extension_association_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateExtensionAssociationOutput,
crate::error::CreateExtensionAssociationError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_extension_association_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_extension_association(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateExtensionAssociationError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_hosted_configuration_version_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateHostedConfigurationVersionOutput,
crate::error::CreateHostedConfigurationVersionError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateHostedConfigurationVersionError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::CreateHostedConfigurationVersionError::unhandled(generic))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::CreateHostedConfigurationVersionError { meta: generic, kind: crate::error::CreateHostedConfigurationVersionErrorKind::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::CreateHostedConfigurationVersionError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ConflictException" => crate::error::CreateHostedConfigurationVersionError { meta: generic, kind: crate::error::CreateHostedConfigurationVersionErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateHostedConfigurationVersionError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"InternalServerException" => crate::error::CreateHostedConfigurationVersionError { meta: generic, kind: crate::error::CreateHostedConfigurationVersionErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateHostedConfigurationVersionError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"PayloadTooLargeException" => crate::error::CreateHostedConfigurationVersionError { meta: generic, kind: crate::error::CreateHostedConfigurationVersionErrorKind::PayloadTooLargeException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::payload_too_large_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_payload_too_large_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateHostedConfigurationVersionError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ResourceNotFoundException" => crate::error::CreateHostedConfigurationVersionError { meta: generic, kind: crate::error::CreateHostedConfigurationVersionErrorKind::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::CreateHostedConfigurationVersionError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ServiceQuotaExceededException" => crate::error::CreateHostedConfigurationVersionError { meta: generic, kind: crate::error::CreateHostedConfigurationVersionErrorKind::ServiceQuotaExceededException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::service_quota_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_quota_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateHostedConfigurationVersionError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
_ => crate::error::CreateHostedConfigurationVersionError::generic(generic)
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_hosted_configuration_version_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateHostedConfigurationVersionOutput,
crate::error::CreateHostedConfigurationVersionError,
> {
Ok({
#[allow(unused_mut)]
let mut output =
crate::output::create_hosted_configuration_version_output::Builder::default();
let _ = response;
output = output.set_application_id(
crate::http_serde::deser_header_create_hosted_configuration_version_create_hosted_configuration_version_output_application_id(response.headers())
.map_err(|_|crate::error::CreateHostedConfigurationVersionError::unhandled("Failed to parse ApplicationId from header `Application-Id"))?
);
output = output.set_configuration_profile_id(
crate::http_serde::deser_header_create_hosted_configuration_version_create_hosted_configuration_version_output_configuration_profile_id(response.headers())
.map_err(|_|crate::error::CreateHostedConfigurationVersionError::unhandled("Failed to parse ConfigurationProfileId from header `Configuration-Profile-Id"))?
);
output = output.set_content(
crate::http_serde::deser_payload_create_hosted_configuration_version_create_hosted_configuration_version_output_content(response.body().as_ref())?
);
output = output.set_content_type(
crate::http_serde::deser_header_create_hosted_configuration_version_create_hosted_configuration_version_output_content_type(response.headers())
.map_err(|_|crate::error::CreateHostedConfigurationVersionError::unhandled("Failed to parse ContentType from header `Content-Type"))?
);
output = output.set_description(
crate::http_serde::deser_header_create_hosted_configuration_version_create_hosted_configuration_version_output_description(response.headers())
.map_err(|_|crate::error::CreateHostedConfigurationVersionError::unhandled("Failed to parse Description from header `Description"))?
);
output = output.set_version_number(
crate::http_serde::deser_header_create_hosted_configuration_version_create_hosted_configuration_version_output_version_number(response.headers())
.map_err(|_|crate::error::CreateHostedConfigurationVersionError::unhandled("Failed to parse VersionNumber from header `Version-Number"))?
);
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_application_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteApplicationOutput, crate::error::DeleteApplicationError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteApplicationError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteApplicationError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::DeleteApplicationError {
meta: generic,
kind: crate::error::DeleteApplicationErrorKind::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::DeleteApplicationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::DeleteApplicationError {
meta: generic,
kind: crate::error::DeleteApplicationErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteApplicationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteApplicationError {
meta: generic,
kind: crate::error::DeleteApplicationErrorKind::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::DeleteApplicationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteApplicationError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_application_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteApplicationOutput, crate::error::DeleteApplicationError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_application_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_configuration_profile_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteConfigurationProfileOutput,
crate::error::DeleteConfigurationProfileError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteConfigurationProfileError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DeleteConfigurationProfileError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::DeleteConfigurationProfileError {
meta: generic,
kind: crate::error::DeleteConfigurationProfileErrorKind::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::DeleteConfigurationProfileError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::DeleteConfigurationProfileError {
meta: generic,
kind: crate::error::DeleteConfigurationProfileErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteConfigurationProfileError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InternalServerException" => crate::error::DeleteConfigurationProfileError {
meta: generic,
kind: crate::error::DeleteConfigurationProfileErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteConfigurationProfileError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteConfigurationProfileError {
meta: generic,
kind: crate::error::DeleteConfigurationProfileErrorKind::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::DeleteConfigurationProfileError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteConfigurationProfileError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_configuration_profile_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteConfigurationProfileOutput,
crate::error::DeleteConfigurationProfileError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_configuration_profile_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_deployment_strategy_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteDeploymentStrategyOutput,
crate::error::DeleteDeploymentStrategyError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteDeploymentStrategyError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DeleteDeploymentStrategyError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::DeleteDeploymentStrategyError {
meta: generic,
kind: crate::error::DeleteDeploymentStrategyErrorKind::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::DeleteDeploymentStrategyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::DeleteDeploymentStrategyError {
meta: generic,
kind: crate::error::DeleteDeploymentStrategyErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteDeploymentStrategyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteDeploymentStrategyError {
meta: generic,
kind: crate::error::DeleteDeploymentStrategyErrorKind::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::DeleteDeploymentStrategyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteDeploymentStrategyError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_deployment_strategy_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteDeploymentStrategyOutput,
crate::error::DeleteDeploymentStrategyError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_deployment_strategy_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_environment_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteEnvironmentOutput, crate::error::DeleteEnvironmentError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteEnvironmentError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteEnvironmentError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::DeleteEnvironmentError {
meta: generic,
kind: crate::error::DeleteEnvironmentErrorKind::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::DeleteEnvironmentError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::DeleteEnvironmentError {
meta: generic,
kind: crate::error::DeleteEnvironmentErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteEnvironmentError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InternalServerException" => crate::error::DeleteEnvironmentError {
meta: generic,
kind: crate::error::DeleteEnvironmentErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteEnvironmentError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteEnvironmentError {
meta: generic,
kind: crate::error::DeleteEnvironmentErrorKind::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::DeleteEnvironmentError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteEnvironmentError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_environment_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteEnvironmentOutput, crate::error::DeleteEnvironmentError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_environment_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_extension_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteExtensionOutput, crate::error::DeleteExtensionError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteExtensionError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteExtensionError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::DeleteExtensionError {
meta: generic,
kind: crate::error::DeleteExtensionErrorKind::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::DeleteExtensionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::DeleteExtensionError {
meta: generic,
kind: crate::error::DeleteExtensionErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteExtensionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteExtensionError {
meta: generic,
kind: crate::error::DeleteExtensionErrorKind::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::DeleteExtensionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteExtensionError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_extension_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteExtensionOutput, crate::error::DeleteExtensionError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_extension_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_extension_association_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteExtensionAssociationOutput,
crate::error::DeleteExtensionAssociationError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteExtensionAssociationError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DeleteExtensionAssociationError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::DeleteExtensionAssociationError {
meta: generic,
kind: crate::error::DeleteExtensionAssociationErrorKind::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::DeleteExtensionAssociationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::DeleteExtensionAssociationError {
meta: generic,
kind: crate::error::DeleteExtensionAssociationErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteExtensionAssociationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteExtensionAssociationError {
meta: generic,
kind: crate::error::DeleteExtensionAssociationErrorKind::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::DeleteExtensionAssociationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteExtensionAssociationError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_extension_association_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteExtensionAssociationOutput,
crate::error::DeleteExtensionAssociationError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_extension_association_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_hosted_configuration_version_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteHostedConfigurationVersionOutput,
crate::error::DeleteHostedConfigurationVersionError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteHostedConfigurationVersionError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DeleteHostedConfigurationVersionError::unhandled(generic))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::DeleteHostedConfigurationVersionError {
meta: generic,
kind: crate::error::DeleteHostedConfigurationVersionErrorKind::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::DeleteHostedConfigurationVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::DeleteHostedConfigurationVersionError {
meta: generic,
kind: crate::error::DeleteHostedConfigurationVersionErrorKind::InternalServerException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteHostedConfigurationVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ResourceNotFoundException" => crate::error::DeleteHostedConfigurationVersionError {
meta: generic,
kind:
crate::error::DeleteHostedConfigurationVersionErrorKind::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::DeleteHostedConfigurationVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
_ => crate::error::DeleteHostedConfigurationVersionError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_hosted_configuration_version_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteHostedConfigurationVersionOutput,
crate::error::DeleteHostedConfigurationVersionError,
> {
Ok({
#[allow(unused_mut)]
let mut output =
crate::output::delete_hosted_configuration_version_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_application_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetApplicationOutput, crate::error::GetApplicationError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetApplicationError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::GetApplicationError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::GetApplicationError {
meta: generic,
kind: crate::error::GetApplicationErrorKind::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::GetApplicationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::GetApplicationError {
meta: generic,
kind: crate::error::GetApplicationErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetApplicationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::GetApplicationError {
meta: generic,
kind: crate::error::GetApplicationErrorKind::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::GetApplicationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetApplicationError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_application_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetApplicationOutput, crate::error::GetApplicationError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_application_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_application(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetApplicationError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_configuration_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetConfigurationOutput, crate::error::GetConfigurationError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetConfigurationError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::GetConfigurationError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::GetConfigurationError {
meta: generic,
kind: crate::error::GetConfigurationErrorKind::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::GetConfigurationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::GetConfigurationError {
meta: generic,
kind: crate::error::GetConfigurationErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetConfigurationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::GetConfigurationError {
meta: generic,
kind: crate::error::GetConfigurationErrorKind::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::GetConfigurationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetConfigurationError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_configuration_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetConfigurationOutput, crate::error::GetConfigurationError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_configuration_output::Builder::default();
let _ = response;
output = output.set_configuration_version(
crate::http_serde::deser_header_get_configuration_get_configuration_output_configuration_version(response.headers())
.map_err(|_|crate::error::GetConfigurationError::unhandled("Failed to parse ConfigurationVersion from header `Configuration-Version"))?
);
output = output.set_content(
crate::http_serde::deser_payload_get_configuration_get_configuration_output_content(
response.body().as_ref(),
)?,
);
output = output.set_content_type(
crate::http_serde::deser_header_get_configuration_get_configuration_output_content_type(response.headers())
.map_err(|_|crate::error::GetConfigurationError::unhandled("Failed to parse ContentType from header `Content-Type"))?
);
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_configuration_profile_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetConfigurationProfileOutput,
crate::error::GetConfigurationProfileError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetConfigurationProfileError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::GetConfigurationProfileError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::GetConfigurationProfileError {
meta: generic,
kind: crate::error::GetConfigurationProfileErrorKind::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::GetConfigurationProfileError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::GetConfigurationProfileError {
meta: generic,
kind: crate::error::GetConfigurationProfileErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetConfigurationProfileError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::GetConfigurationProfileError {
meta: generic,
kind: crate::error::GetConfigurationProfileErrorKind::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::GetConfigurationProfileError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetConfigurationProfileError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_configuration_profile_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetConfigurationProfileOutput,
crate::error::GetConfigurationProfileError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_configuration_profile_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_configuration_profile(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetConfigurationProfileError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_deployment_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetDeploymentOutput, crate::error::GetDeploymentError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetDeploymentError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::GetDeploymentError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::GetDeploymentError {
meta: generic,
kind: crate::error::GetDeploymentErrorKind::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::GetDeploymentError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::GetDeploymentError {
meta: generic,
kind: crate::error::GetDeploymentErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::GetDeploymentError {
meta: generic,
kind: crate::error::GetDeploymentErrorKind::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::GetDeploymentError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetDeploymentError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_deployment_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetDeploymentOutput, crate::error::GetDeploymentError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_deployment_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_deployment(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetDeploymentError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_deployment_strategy_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetDeploymentStrategyOutput,
crate::error::GetDeploymentStrategyError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetDeploymentStrategyError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::GetDeploymentStrategyError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::GetDeploymentStrategyError {
meta: generic,
kind: crate::error::GetDeploymentStrategyErrorKind::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::GetDeploymentStrategyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::GetDeploymentStrategyError {
meta: generic,
kind: crate::error::GetDeploymentStrategyErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentStrategyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::GetDeploymentStrategyError {
meta: generic,
kind: crate::error::GetDeploymentStrategyErrorKind::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::GetDeploymentStrategyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetDeploymentStrategyError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_deployment_strategy_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetDeploymentStrategyOutput,
crate::error::GetDeploymentStrategyError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_deployment_strategy_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_deployment_strategy(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetDeploymentStrategyError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_environment_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetEnvironmentOutput, crate::error::GetEnvironmentError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetEnvironmentError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::GetEnvironmentError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::GetEnvironmentError {
meta: generic,
kind: crate::error::GetEnvironmentErrorKind::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::GetEnvironmentError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::GetEnvironmentError {
meta: generic,
kind: crate::error::GetEnvironmentErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetEnvironmentError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::GetEnvironmentError {
meta: generic,
kind: crate::error::GetEnvironmentErrorKind::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::GetEnvironmentError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetEnvironmentError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_environment_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetEnvironmentOutput, crate::error::GetEnvironmentError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_environment_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_environment(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetEnvironmentError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_extension_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetExtensionOutput, crate::error::GetExtensionError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetExtensionError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::GetExtensionError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::GetExtensionError {
meta: generic,
kind: crate::error::GetExtensionErrorKind::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::GetExtensionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::GetExtensionError {
meta: generic,
kind: crate::error::GetExtensionErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetExtensionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::GetExtensionError {
meta: generic,
kind: crate::error::GetExtensionErrorKind::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::GetExtensionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetExtensionError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_extension_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetExtensionOutput, crate::error::GetExtensionError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_extension_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_extension(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetExtensionError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_extension_association_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetExtensionAssociationOutput,
crate::error::GetExtensionAssociationError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetExtensionAssociationError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::GetExtensionAssociationError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::GetExtensionAssociationError {
meta: generic,
kind: crate::error::GetExtensionAssociationErrorKind::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::GetExtensionAssociationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::GetExtensionAssociationError {
meta: generic,
kind: crate::error::GetExtensionAssociationErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetExtensionAssociationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::GetExtensionAssociationError {
meta: generic,
kind: crate::error::GetExtensionAssociationErrorKind::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::GetExtensionAssociationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetExtensionAssociationError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_extension_association_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetExtensionAssociationOutput,
crate::error::GetExtensionAssociationError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_extension_association_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_extension_association(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetExtensionAssociationError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_hosted_configuration_version_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetHostedConfigurationVersionOutput,
crate::error::GetHostedConfigurationVersionError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetHostedConfigurationVersionError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::GetHostedConfigurationVersionError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::GetHostedConfigurationVersionError {
meta: generic,
kind: crate::error::GetHostedConfigurationVersionErrorKind::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::GetHostedConfigurationVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::GetHostedConfigurationVersionError {
meta: generic,
kind: crate::error::GetHostedConfigurationVersionErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetHostedConfigurationVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::GetHostedConfigurationVersionError {
meta: generic,
kind: crate::error::GetHostedConfigurationVersionErrorKind::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::GetHostedConfigurationVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
_ => crate::error::GetHostedConfigurationVersionError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_hosted_configuration_version_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetHostedConfigurationVersionOutput,
crate::error::GetHostedConfigurationVersionError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_hosted_configuration_version_output::Builder::default();
let _ = response;
output = output.set_application_id(
crate::http_serde::deser_header_get_hosted_configuration_version_get_hosted_configuration_version_output_application_id(response.headers())
.map_err(|_|crate::error::GetHostedConfigurationVersionError::unhandled("Failed to parse ApplicationId from header `Application-Id"))?
);
output = output.set_configuration_profile_id(
crate::http_serde::deser_header_get_hosted_configuration_version_get_hosted_configuration_version_output_configuration_profile_id(response.headers())
.map_err(|_|crate::error::GetHostedConfigurationVersionError::unhandled("Failed to parse ConfigurationProfileId from header `Configuration-Profile-Id"))?
);
output = output.set_content(
crate::http_serde::deser_payload_get_hosted_configuration_version_get_hosted_configuration_version_output_content(response.body().as_ref())?
);
output = output.set_content_type(
crate::http_serde::deser_header_get_hosted_configuration_version_get_hosted_configuration_version_output_content_type(response.headers())
.map_err(|_|crate::error::GetHostedConfigurationVersionError::unhandled("Failed to parse ContentType from header `Content-Type"))?
);
output = output.set_description(
crate::http_serde::deser_header_get_hosted_configuration_version_get_hosted_configuration_version_output_description(response.headers())
.map_err(|_|crate::error::GetHostedConfigurationVersionError::unhandled("Failed to parse Description from header `Description"))?
);
output = output.set_version_number(
crate::http_serde::deser_header_get_hosted_configuration_version_get_hosted_configuration_version_output_version_number(response.headers())
.map_err(|_|crate::error::GetHostedConfigurationVersionError::unhandled("Failed to parse VersionNumber from header `Version-Number"))?
);
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_applications_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListApplicationsOutput, crate::error::ListApplicationsError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListApplicationsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListApplicationsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::ListApplicationsError {
meta: generic,
kind: crate::error::ListApplicationsErrorKind::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::ListApplicationsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::ListApplicationsError {
meta: generic,
kind: crate::error::ListApplicationsErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListApplicationsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListApplicationsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_applications_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListApplicationsOutput, crate::error::ListApplicationsError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_applications_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_applications(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListApplicationsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_configuration_profiles_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListConfigurationProfilesOutput,
crate::error::ListConfigurationProfilesError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListConfigurationProfilesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListConfigurationProfilesError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::ListConfigurationProfilesError {
meta: generic,
kind: crate::error::ListConfigurationProfilesErrorKind::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::ListConfigurationProfilesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::ListConfigurationProfilesError {
meta: generic,
kind: crate::error::ListConfigurationProfilesErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListConfigurationProfilesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListConfigurationProfilesError {
meta: generic,
kind: crate::error::ListConfigurationProfilesErrorKind::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::ListConfigurationProfilesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListConfigurationProfilesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_configuration_profiles_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListConfigurationProfilesOutput,
crate::error::ListConfigurationProfilesError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_configuration_profiles_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_configuration_profiles(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListConfigurationProfilesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_deployments_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListDeploymentsOutput, crate::error::ListDeploymentsError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListDeploymentsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListDeploymentsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::ListDeploymentsError {
meta: generic,
kind: crate::error::ListDeploymentsErrorKind::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::ListDeploymentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::ListDeploymentsError {
meta: generic,
kind: crate::error::ListDeploymentsErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListDeploymentsError {
meta: generic,
kind: crate::error::ListDeploymentsErrorKind::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::ListDeploymentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListDeploymentsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_deployments_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListDeploymentsOutput, crate::error::ListDeploymentsError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_deployments_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_deployments(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListDeploymentsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_deployment_strategies_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListDeploymentStrategiesOutput,
crate::error::ListDeploymentStrategiesError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListDeploymentStrategiesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListDeploymentStrategiesError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::ListDeploymentStrategiesError {
meta: generic,
kind: crate::error::ListDeploymentStrategiesErrorKind::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::ListDeploymentStrategiesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::ListDeploymentStrategiesError {
meta: generic,
kind: crate::error::ListDeploymentStrategiesErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentStrategiesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListDeploymentStrategiesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_deployment_strategies_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListDeploymentStrategiesOutput,
crate::error::ListDeploymentStrategiesError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_deployment_strategies_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_deployment_strategies(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListDeploymentStrategiesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_environments_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListEnvironmentsOutput, crate::error::ListEnvironmentsError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListEnvironmentsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListEnvironmentsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::ListEnvironmentsError {
meta: generic,
kind: crate::error::ListEnvironmentsErrorKind::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::ListEnvironmentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::ListEnvironmentsError {
meta: generic,
kind: crate::error::ListEnvironmentsErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListEnvironmentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListEnvironmentsError {
meta: generic,
kind: crate::error::ListEnvironmentsErrorKind::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::ListEnvironmentsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListEnvironmentsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_environments_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListEnvironmentsOutput, crate::error::ListEnvironmentsError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_environments_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_environments(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListEnvironmentsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_extension_associations_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListExtensionAssociationsOutput,
crate::error::ListExtensionAssociationsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListExtensionAssociationsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListExtensionAssociationsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::ListExtensionAssociationsError {
meta: generic,
kind: crate::error::ListExtensionAssociationsErrorKind::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::ListExtensionAssociationsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::ListExtensionAssociationsError {
meta: generic,
kind: crate::error::ListExtensionAssociationsErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListExtensionAssociationsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListExtensionAssociationsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_extension_associations_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListExtensionAssociationsOutput,
crate::error::ListExtensionAssociationsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_extension_associations_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_extension_associations(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListExtensionAssociationsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_extensions_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListExtensionsOutput, crate::error::ListExtensionsError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListExtensionsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListExtensionsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::ListExtensionsError {
meta: generic,
kind: crate::error::ListExtensionsErrorKind::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::ListExtensionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::ListExtensionsError {
meta: generic,
kind: crate::error::ListExtensionsErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListExtensionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListExtensionsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_extensions_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListExtensionsOutput, crate::error::ListExtensionsError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_extensions_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_extensions(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListExtensionsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_hosted_configuration_versions_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListHostedConfigurationVersionsOutput,
crate::error::ListHostedConfigurationVersionsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListHostedConfigurationVersionsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListHostedConfigurationVersionsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::ListHostedConfigurationVersionsError {
meta: generic,
kind: crate::error::ListHostedConfigurationVersionsErrorKind::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::ListHostedConfigurationVersionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::ListHostedConfigurationVersionsError {
meta: generic,
kind: crate::error::ListHostedConfigurationVersionsErrorKind::InternalServerException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListHostedConfigurationVersionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ResourceNotFoundException" => crate::error::ListHostedConfigurationVersionsError {
meta: generic,
kind: crate::error::ListHostedConfigurationVersionsErrorKind::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::ListHostedConfigurationVersionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
_ => crate::error::ListHostedConfigurationVersionsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_hosted_configuration_versions_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListHostedConfigurationVersionsOutput,
crate::error::ListHostedConfigurationVersionsError,
> {
Ok({
#[allow(unused_mut)]
let mut output =
crate::output::list_hosted_configuration_versions_output::Builder::default();
let _ = response;
output =
crate::json_deser::deser_operation_crate_operation_list_hosted_configuration_versions(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListHostedConfigurationVersionsError::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
}),
},
"InternalServerException" => crate::error::ListTagsForResourceError {
meta: generic,
kind: crate::error::ListTagsForResourceErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTagsForResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListTagsForResourceError {
meta: generic,
kind: crate::error::ListTagsForResourceErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTagsForResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => 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_start_deployment_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StartDeploymentOutput, crate::error::StartDeploymentError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StartDeploymentError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::StartDeploymentError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::StartDeploymentError {
meta: generic,
kind: crate::error::StartDeploymentErrorKind::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::StartDeploymentError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::StartDeploymentError {
meta: generic,
kind: crate::error::StartDeploymentErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartDeploymentError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InternalServerException" => crate::error::StartDeploymentError {
meta: generic,
kind: crate::error::StartDeploymentErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartDeploymentError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::StartDeploymentError {
meta: generic,
kind: crate::error::StartDeploymentErrorKind::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::StartDeploymentError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::StartDeploymentError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_deployment_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StartDeploymentOutput, crate::error::StartDeploymentError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::start_deployment_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_start_deployment(
response.body().as_ref(),
output,
)
.map_err(crate::error::StartDeploymentError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_deployment_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StopDeploymentOutput, crate::error::StopDeploymentError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StopDeploymentError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::StopDeploymentError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::StopDeploymentError {
meta: generic,
kind: crate::error::StopDeploymentErrorKind::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::StopDeploymentError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::StopDeploymentError {
meta: generic,
kind: crate::error::StopDeploymentErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopDeploymentError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::StopDeploymentError {
meta: generic,
kind: crate::error::StopDeploymentErrorKind::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::StopDeploymentError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::StopDeploymentError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_deployment_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StopDeploymentOutput, crate::error::StopDeploymentError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::stop_deployment_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_stop_deployment(
response.body().as_ref(),
output,
)
.map_err(crate::error::StopDeploymentError::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
}),
},
"InternalServerException" => crate::error::TagResourceError {
meta: generic,
kind: crate::error::TagResourceErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::TagResourceError {
meta: generic,
kind: crate::error::TagResourceErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => 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
}),
},
"InternalServerException" => crate::error::UntagResourceError {
meta: generic,
kind: crate::error::UntagResourceErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UntagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UntagResourceError {
meta: generic,
kind: crate::error::UntagResourceErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UntagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => 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_application_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateApplicationOutput, crate::error::UpdateApplicationError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateApplicationError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UpdateApplicationError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::UpdateApplicationError {
meta: generic,
kind: crate::error::UpdateApplicationErrorKind::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::UpdateApplicationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::UpdateApplicationError {
meta: generic,
kind: crate::error::UpdateApplicationErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateApplicationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpdateApplicationError {
meta: generic,
kind: crate::error::UpdateApplicationErrorKind::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::UpdateApplicationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateApplicationError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_application_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateApplicationOutput, crate::error::UpdateApplicationError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_application_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_application(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateApplicationError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_configuration_profile_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateConfigurationProfileOutput,
crate::error::UpdateConfigurationProfileError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateConfigurationProfileError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::UpdateConfigurationProfileError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::UpdateConfigurationProfileError {
meta: generic,
kind: crate::error::UpdateConfigurationProfileErrorKind::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::UpdateConfigurationProfileError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::UpdateConfigurationProfileError {
meta: generic,
kind: crate::error::UpdateConfigurationProfileErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateConfigurationProfileError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpdateConfigurationProfileError {
meta: generic,
kind: crate::error::UpdateConfigurationProfileErrorKind::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::UpdateConfigurationProfileError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateConfigurationProfileError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_configuration_profile_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateConfigurationProfileOutput,
crate::error::UpdateConfigurationProfileError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_configuration_profile_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_configuration_profile(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateConfigurationProfileError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_deployment_strategy_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateDeploymentStrategyOutput,
crate::error::UpdateDeploymentStrategyError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateDeploymentStrategyError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::UpdateDeploymentStrategyError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::UpdateDeploymentStrategyError {
meta: generic,
kind: crate::error::UpdateDeploymentStrategyErrorKind::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::UpdateDeploymentStrategyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::UpdateDeploymentStrategyError {
meta: generic,
kind: crate::error::UpdateDeploymentStrategyErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentStrategyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpdateDeploymentStrategyError {
meta: generic,
kind: crate::error::UpdateDeploymentStrategyErrorKind::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::UpdateDeploymentStrategyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateDeploymentStrategyError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_deployment_strategy_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateDeploymentStrategyOutput,
crate::error::UpdateDeploymentStrategyError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_deployment_strategy_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_deployment_strategy(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateDeploymentStrategyError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_environment_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateEnvironmentOutput, crate::error::UpdateEnvironmentError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateEnvironmentError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UpdateEnvironmentError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::UpdateEnvironmentError {
meta: generic,
kind: crate::error::UpdateEnvironmentErrorKind::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::UpdateEnvironmentError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::UpdateEnvironmentError {
meta: generic,
kind: crate::error::UpdateEnvironmentErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateEnvironmentError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpdateEnvironmentError {
meta: generic,
kind: crate::error::UpdateEnvironmentErrorKind::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::UpdateEnvironmentError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateEnvironmentError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_environment_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateEnvironmentOutput, crate::error::UpdateEnvironmentError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_environment_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_environment(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateEnvironmentError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_extension_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateExtensionOutput, crate::error::UpdateExtensionError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateExtensionError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UpdateExtensionError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::UpdateExtensionError {
meta: generic,
kind: crate::error::UpdateExtensionErrorKind::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::UpdateExtensionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::UpdateExtensionError {
meta: generic,
kind: crate::error::UpdateExtensionErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateExtensionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InternalServerException" => crate::error::UpdateExtensionError {
meta: generic,
kind: crate::error::UpdateExtensionErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateExtensionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpdateExtensionError {
meta: generic,
kind: crate::error::UpdateExtensionErrorKind::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::UpdateExtensionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateExtensionError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_extension_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateExtensionOutput, crate::error::UpdateExtensionError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_extension_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_extension(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateExtensionError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_extension_association_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateExtensionAssociationOutput,
crate::error::UpdateExtensionAssociationError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateExtensionAssociationError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::UpdateExtensionAssociationError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::UpdateExtensionAssociationError {
meta: generic,
kind: crate::error::UpdateExtensionAssociationErrorKind::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::UpdateExtensionAssociationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::UpdateExtensionAssociationError {
meta: generic,
kind: crate::error::UpdateExtensionAssociationErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateExtensionAssociationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpdateExtensionAssociationError {
meta: generic,
kind: crate::error::UpdateExtensionAssociationErrorKind::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::UpdateExtensionAssociationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateExtensionAssociationError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_extension_association_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateExtensionAssociationOutput,
crate::error::UpdateExtensionAssociationError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_extension_association_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_extension_association(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateExtensionAssociationError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_validate_configuration_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ValidateConfigurationOutput,
crate::error::ValidateConfigurationError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ValidateConfigurationError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ValidateConfigurationError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::ValidateConfigurationError {
meta: generic,
kind: crate::error::ValidateConfigurationErrorKind::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::ValidateConfigurationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerException" => crate::error::ValidateConfigurationError {
meta: generic,
kind: crate::error::ValidateConfigurationErrorKind::InternalServerException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_server_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ValidateConfigurationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ValidateConfigurationError {
meta: generic,
kind: crate::error::ValidateConfigurationErrorKind::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::ValidateConfigurationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ValidateConfigurationError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_validate_configuration_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ValidateConfigurationOutput,
crate::error::ValidateConfigurationError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::validate_configuration_output::Builder::default();
let _ = response;
output.build()
})
}