#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_link_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateLinkOutput, crate::error::CreateLinkError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateLinkError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateLinkError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ConflictException" => {
crate::error::CreateLinkError {
meta: generic,
kind: crate::error::CreateLinkErrorKind::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::CreateLinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_create_link_conflict_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::CreateLinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InternalServiceFault" => crate::error::CreateLinkError {
meta: generic,
kind: crate::error::CreateLinkErrorKind::InternalServiceFault({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_fault::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_fault_json_err(response.body().as_ref(), output).map_err(crate::error::CreateLinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_create_link_internal_service_fault_amzn_error_type(response.headers())
.map_err(|_|crate::error::CreateLinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidParameterException" => crate::error::CreateLinkError {
meta: generic,
kind: crate::error::CreateLinkErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateLinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_create_link_invalid_parameter_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::CreateLinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingRequiredParameterException" => crate::error::CreateLinkError {
meta: generic,
kind: crate::error::CreateLinkErrorKind::MissingRequiredParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_required_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_required_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateLinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_create_link_missing_required_parameter_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::CreateLinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceQuotaExceededException" => crate::error::CreateLinkError {
meta: generic,
kind: crate::error::CreateLinkErrorKind::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::CreateLinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_create_link_service_quota_exceeded_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::CreateLinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateLinkError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_link_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateLinkOutput, crate::error::CreateLinkError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_link_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_link(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateLinkError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_sink_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateSinkOutput, crate::error::CreateSinkError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateSinkError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateSinkError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ConflictException" => {
crate::error::CreateSinkError {
meta: generic,
kind: crate::error::CreateSinkErrorKind::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::CreateSinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_create_sink_conflict_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::CreateSinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InternalServiceFault" => crate::error::CreateSinkError {
meta: generic,
kind: crate::error::CreateSinkErrorKind::InternalServiceFault({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_fault::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_fault_json_err(response.body().as_ref(), output).map_err(crate::error::CreateSinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_create_sink_internal_service_fault_amzn_error_type(response.headers())
.map_err(|_|crate::error::CreateSinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidParameterException" => crate::error::CreateSinkError {
meta: generic,
kind: crate::error::CreateSinkErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateSinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_create_sink_invalid_parameter_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::CreateSinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingRequiredParameterException" => crate::error::CreateSinkError {
meta: generic,
kind: crate::error::CreateSinkErrorKind::MissingRequiredParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_required_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_required_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateSinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_create_sink_missing_required_parameter_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::CreateSinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceQuotaExceededException" => crate::error::CreateSinkError {
meta: generic,
kind: crate::error::CreateSinkErrorKind::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::CreateSinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_create_sink_service_quota_exceeded_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::CreateSinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateSinkError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_sink_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateSinkOutput, crate::error::CreateSinkError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_sink_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_sink(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateSinkError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_link_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteLinkOutput, crate::error::DeleteLinkError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteLinkError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteLinkError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServiceFault" => crate::error::DeleteLinkError {
meta: generic,
kind: crate::error::DeleteLinkErrorKind::InternalServiceFault({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_fault::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_fault_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteLinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_delete_link_internal_service_fault_amzn_error_type(response.headers())
.map_err(|_|crate::error::DeleteLinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidParameterException" => crate::error::DeleteLinkError {
meta: generic,
kind: crate::error::DeleteLinkErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteLinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_delete_link_invalid_parameter_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::DeleteLinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingRequiredParameterException" => crate::error::DeleteLinkError {
meta: generic,
kind: crate::error::DeleteLinkErrorKind::MissingRequiredParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_required_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_required_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteLinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_delete_link_missing_required_parameter_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::DeleteLinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteLinkError {
meta: generic,
kind: crate::error::DeleteLinkErrorKind::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::DeleteLinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_delete_link_resource_not_found_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::DeleteLinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteLinkError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_link_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteLinkOutput, crate::error::DeleteLinkError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_link_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_sink_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteSinkOutput, crate::error::DeleteSinkError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteSinkError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteSinkError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ConflictException" => {
crate::error::DeleteSinkError {
meta: generic,
kind: crate::error::DeleteSinkErrorKind::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::DeleteSinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_delete_sink_conflict_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::DeleteSinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InternalServiceFault" => crate::error::DeleteSinkError {
meta: generic,
kind: crate::error::DeleteSinkErrorKind::InternalServiceFault({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_fault::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_fault_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteSinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_delete_sink_internal_service_fault_amzn_error_type(response.headers())
.map_err(|_|crate::error::DeleteSinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidParameterException" => crate::error::DeleteSinkError {
meta: generic,
kind: crate::error::DeleteSinkErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteSinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_delete_sink_invalid_parameter_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::DeleteSinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingRequiredParameterException" => crate::error::DeleteSinkError {
meta: generic,
kind: crate::error::DeleteSinkErrorKind::MissingRequiredParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_required_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_required_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteSinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_delete_sink_missing_required_parameter_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::DeleteSinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteSinkError {
meta: generic,
kind: crate::error::DeleteSinkErrorKind::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::DeleteSinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_delete_sink_resource_not_found_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::DeleteSinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteSinkError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_sink_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteSinkOutput, crate::error::DeleteSinkError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_sink_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_link_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetLinkOutput, crate::error::GetLinkError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetLinkError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::GetLinkError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServiceFault" => crate::error::GetLinkError {
meta: generic,
kind: crate::error::GetLinkErrorKind::InternalServiceFault({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_fault::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_fault_json_err(response.body().as_ref(), output).map_err(crate::error::GetLinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_get_link_internal_service_fault_amzn_error_type(response.headers())
.map_err(|_|crate::error::GetLinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidParameterException" => crate::error::GetLinkError {
meta: generic,
kind: crate::error::GetLinkErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetLinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_get_link_invalid_parameter_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::GetLinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingRequiredParameterException" => crate::error::GetLinkError {
meta: generic,
kind: crate::error::GetLinkErrorKind::MissingRequiredParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_required_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_required_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetLinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_get_link_missing_required_parameter_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::GetLinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::GetLinkError {
meta: generic,
kind: crate::error::GetLinkErrorKind::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::GetLinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_get_link_resource_not_found_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::GetLinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetLinkError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_link_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetLinkOutput, crate::error::GetLinkError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_link_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_link(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetLinkError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_sink_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetSinkOutput, crate::error::GetSinkError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetSinkError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::GetSinkError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServiceFault" => crate::error::GetSinkError {
meta: generic,
kind: crate::error::GetSinkErrorKind::InternalServiceFault({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_fault::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_fault_json_err(response.body().as_ref(), output).map_err(crate::error::GetSinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_get_sink_internal_service_fault_amzn_error_type(response.headers())
.map_err(|_|crate::error::GetSinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidParameterException" => crate::error::GetSinkError {
meta: generic,
kind: crate::error::GetSinkErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetSinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_get_sink_invalid_parameter_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::GetSinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingRequiredParameterException" => crate::error::GetSinkError {
meta: generic,
kind: crate::error::GetSinkErrorKind::MissingRequiredParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_required_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_required_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetSinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_get_sink_missing_required_parameter_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::GetSinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::GetSinkError {
meta: generic,
kind: crate::error::GetSinkErrorKind::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::GetSinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_get_sink_resource_not_found_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::GetSinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetSinkError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_sink_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetSinkOutput, crate::error::GetSinkError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_sink_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_sink(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetSinkError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_sink_policy_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetSinkPolicyOutput, crate::error::GetSinkPolicyError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetSinkPolicyError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::GetSinkPolicyError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServiceFault" => crate::error::GetSinkPolicyError {
meta: generic,
kind: crate::error::GetSinkPolicyErrorKind::InternalServiceFault({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_fault::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_fault_json_err(response.body().as_ref(), output).map_err(crate::error::GetSinkPolicyError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_get_sink_policy_internal_service_fault_amzn_error_type(response.headers())
.map_err(|_|crate::error::GetSinkPolicyError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidParameterException" => crate::error::GetSinkPolicyError {
meta: generic,
kind: crate::error::GetSinkPolicyErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetSinkPolicyError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_get_sink_policy_invalid_parameter_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::GetSinkPolicyError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingRequiredParameterException" => crate::error::GetSinkPolicyError {
meta: generic,
kind: crate::error::GetSinkPolicyErrorKind::MissingRequiredParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_required_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_required_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetSinkPolicyError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_get_sink_policy_missing_required_parameter_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::GetSinkPolicyError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::GetSinkPolicyError {
meta: generic,
kind: crate::error::GetSinkPolicyErrorKind::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::GetSinkPolicyError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_get_sink_policy_resource_not_found_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::GetSinkPolicyError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetSinkPolicyError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_sink_policy_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetSinkPolicyOutput, crate::error::GetSinkPolicyError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_sink_policy_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_sink_policy(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetSinkPolicyError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_attached_links_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListAttachedLinksOutput, crate::error::ListAttachedLinksError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListAttachedLinksError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListAttachedLinksError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServiceFault" => crate::error::ListAttachedLinksError {
meta: generic,
kind: crate::error::ListAttachedLinksErrorKind::InternalServiceFault({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_fault::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_fault_json_err(response.body().as_ref(), output).map_err(crate::error::ListAttachedLinksError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_list_attached_links_internal_service_fault_amzn_error_type(response.headers())
.map_err(|_|crate::error::ListAttachedLinksError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidParameterException" => crate::error::ListAttachedLinksError {
meta: generic,
kind: crate::error::ListAttachedLinksErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAttachedLinksError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_list_attached_links_invalid_parameter_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::ListAttachedLinksError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingRequiredParameterException" => crate::error::ListAttachedLinksError {
meta: generic,
kind: crate::error::ListAttachedLinksErrorKind::MissingRequiredParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_required_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_required_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListAttachedLinksError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_list_attached_links_missing_required_parameter_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::ListAttachedLinksError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListAttachedLinksError {
meta: generic,
kind: crate::error::ListAttachedLinksErrorKind::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::ListAttachedLinksError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_list_attached_links_resource_not_found_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::ListAttachedLinksError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListAttachedLinksError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_attached_links_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListAttachedLinksOutput, crate::error::ListAttachedLinksError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_attached_links_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_attached_links(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListAttachedLinksError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_links_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListLinksOutput, crate::error::ListLinksError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListLinksError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListLinksError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServiceFault" => crate::error::ListLinksError {
meta: generic,
kind: crate::error::ListLinksErrorKind::InternalServiceFault({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_fault::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_fault_json_err(response.body().as_ref(), output).map_err(crate::error::ListLinksError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_list_links_internal_service_fault_amzn_error_type(response.headers())
.map_err(|_|crate::error::ListLinksError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidParameterException" => crate::error::ListLinksError {
meta: generic,
kind: crate::error::ListLinksErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListLinksError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_list_links_invalid_parameter_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::ListLinksError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListLinksError {
meta: generic,
kind: crate::error::ListLinksErrorKind::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::ListLinksError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_list_links_resource_not_found_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::ListLinksError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListLinksError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_links_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListLinksOutput, crate::error::ListLinksError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_links_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_links(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListLinksError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_sinks_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListSinksOutput, crate::error::ListSinksError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListSinksError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListSinksError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServiceFault" => crate::error::ListSinksError {
meta: generic,
kind: crate::error::ListSinksErrorKind::InternalServiceFault({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_fault::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_fault_json_err(response.body().as_ref(), output).map_err(crate::error::ListSinksError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_list_sinks_internal_service_fault_amzn_error_type(response.headers())
.map_err(|_|crate::error::ListSinksError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidParameterException" => crate::error::ListSinksError {
meta: generic,
kind: crate::error::ListSinksErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListSinksError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_list_sinks_invalid_parameter_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::ListSinksError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListSinksError {
meta: generic,
kind: crate::error::ListSinksErrorKind::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::ListSinksError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_list_sinks_resource_not_found_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::ListSinksError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListSinksError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_sinks_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListSinksOutput, crate::error::ListSinksError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_sinks_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_sinks(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListSinksError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_tags_for_resource_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListTagsForResourceOutput,
crate::error::ListTagsForResourceError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListTagsForResourceError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListTagsForResourceError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ResourceNotFoundException" => crate::error::ListTagsForResourceError {
meta: generic,
kind: crate::error::ListTagsForResourceErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTagsForResourceError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_list_tags_for_resource_resource_not_found_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::ListTagsForResourceError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::ListTagsForResourceError {
meta: generic,
kind: crate::error::ListTagsForResourceErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTagsForResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListTagsForResourceError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_tags_for_resource_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListTagsForResourceOutput,
crate::error::ListTagsForResourceError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_tags_for_resource_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_tags_for_resource(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListTagsForResourceError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_put_sink_policy_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::PutSinkPolicyOutput, crate::error::PutSinkPolicyError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::PutSinkPolicyError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::PutSinkPolicyError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServiceFault" => crate::error::PutSinkPolicyError {
meta: generic,
kind: crate::error::PutSinkPolicyErrorKind::InternalServiceFault({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_fault::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_fault_json_err(response.body().as_ref(), output).map_err(crate::error::PutSinkPolicyError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_put_sink_policy_internal_service_fault_amzn_error_type(response.headers())
.map_err(|_|crate::error::PutSinkPolicyError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidParameterException" => crate::error::PutSinkPolicyError {
meta: generic,
kind: crate::error::PutSinkPolicyErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutSinkPolicyError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_put_sink_policy_invalid_parameter_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::PutSinkPolicyError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingRequiredParameterException" => crate::error::PutSinkPolicyError {
meta: generic,
kind: crate::error::PutSinkPolicyErrorKind::MissingRequiredParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_required_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_required_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutSinkPolicyError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_put_sink_policy_missing_required_parameter_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::PutSinkPolicyError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::PutSinkPolicyError {
meta: generic,
kind: crate::error::PutSinkPolicyErrorKind::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::PutSinkPolicyError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_put_sink_policy_resource_not_found_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::PutSinkPolicyError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::PutSinkPolicyError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_put_sink_policy_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::PutSinkPolicyOutput, crate::error::PutSinkPolicyError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::put_sink_policy_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_put_sink_policy(
response.body().as_ref(),
output,
)
.map_err(crate::error::PutSinkPolicyError::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 {
"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 = output.set_amzn_error_type(
crate::http_serde::deser_header_tag_resource_resource_not_found_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::TagResourceError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyTagsException" => crate::error::TagResourceError {
meta: generic,
kind: crate::error::TagResourceErrorKind::TooManyTagsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_tags_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_tags_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::TagResourceError {
meta: generic,
kind: crate::error::TagResourceErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::TagResourceError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_tag_resource_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::TagResourceOutput, crate::error::TagResourceError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::tag_resource_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_untag_resource_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UntagResourceOutput, crate::error::UntagResourceError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UntagResourceError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UntagResourceError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"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 = output.set_amzn_error_type(
crate::http_serde::deser_header_untag_resource_resource_not_found_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::UntagResourceError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::UntagResourceError {
meta: generic,
kind: crate::error::UntagResourceErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UntagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UntagResourceError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_untag_resource_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UntagResourceOutput, crate::error::UntagResourceError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::untag_resource_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_link_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateLinkOutput, crate::error::UpdateLinkError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateLinkError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UpdateLinkError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServiceFault" => crate::error::UpdateLinkError {
meta: generic,
kind: crate::error::UpdateLinkErrorKind::InternalServiceFault({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::internal_service_fault::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_service_fault_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateLinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_update_link_internal_service_fault_amzn_error_type(response.headers())
.map_err(|_|crate::error::UpdateLinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidParameterException" => crate::error::UpdateLinkError {
meta: generic,
kind: crate::error::UpdateLinkErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateLinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_update_link_invalid_parameter_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::UpdateLinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingRequiredParameterException" => crate::error::UpdateLinkError {
meta: generic,
kind: crate::error::UpdateLinkErrorKind::MissingRequiredParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_required_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_required_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateLinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_update_link_missing_required_parameter_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::UpdateLinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpdateLinkError {
meta: generic,
kind: crate::error::UpdateLinkErrorKind::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::UpdateLinkError::unhandled)?;
output = output.set_amzn_error_type(
crate::http_serde::deser_header_update_link_resource_not_found_exception_amzn_error_type(response.headers())
.map_err(|_|crate::error::UpdateLinkError::unhandled("Failed to parse amznErrorType from header `x-amzn-ErrorType"))?
);
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateLinkError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_link_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateLinkOutput, crate::error::UpdateLinkError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_link_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_link(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateLinkError::unhandled)?;
output.build()
})
}