#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_entities_detection_v2_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeEntitiesDetectionV2JobOutput,
crate::error::DescribeEntitiesDetectionV2JobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeEntitiesDetectionV2JobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeEntitiesDetectionV2JobError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServerException" => crate::error::DescribeEntitiesDetectionV2JobError {
meta: generic,
kind: crate::error::DescribeEntitiesDetectionV2JobErrorKind::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::DescribeEntitiesDetectionV2JobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::DescribeEntitiesDetectionV2JobError {
meta: generic,
kind: crate::error::DescribeEntitiesDetectionV2JobErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeEntitiesDetectionV2JobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeEntitiesDetectionV2JobError {
meta: generic,
kind: crate::error::DescribeEntitiesDetectionV2JobErrorKind::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::DescribeEntitiesDetectionV2JobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"TooManyRequestsException" => crate::error::DescribeEntitiesDetectionV2JobError {
meta: generic,
kind: crate::error::DescribeEntitiesDetectionV2JobErrorKind::TooManyRequestsException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeEntitiesDetectionV2JobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
_ => crate::error::DescribeEntitiesDetectionV2JobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_entities_detection_v2_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeEntitiesDetectionV2JobOutput,
crate::error::DescribeEntitiesDetectionV2JobError,
> {
Ok({
#[allow(unused_mut)]
let mut output =
crate::output::describe_entities_detection_v2_job_output::Builder::default();
let _ = response;
output =
crate::json_deser::deser_operation_crate_operation_describe_entities_detection_v2_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeEntitiesDetectionV2JobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_icd10_cm_inference_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeIcd10CmInferenceJobOutput,
crate::error::DescribeICD10CMInferenceJobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeICD10CMInferenceJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeICD10CMInferenceJobError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServerException" => crate::error::DescribeICD10CMInferenceJobError {
meta: generic,
kind: crate::error::DescribeICD10CMInferenceJobErrorKind::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::DescribeICD10CMInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::DescribeICD10CMInferenceJobError {
meta: generic,
kind: crate::error::DescribeICD10CMInferenceJobErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeICD10CMInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeICD10CMInferenceJobError {
meta: generic,
kind: crate::error::DescribeICD10CMInferenceJobErrorKind::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::DescribeICD10CMInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::DescribeICD10CMInferenceJobError {
meta: generic,
kind: crate::error::DescribeICD10CMInferenceJobErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeICD10CMInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeICD10CMInferenceJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_icd10_cm_inference_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeIcd10CmInferenceJobOutput,
crate::error::DescribeICD10CMInferenceJobError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_icd10_cm_inference_job_output::Builder::default();
let _ = response;
output =
crate::json_deser::deser_operation_crate_operation_describe_icd10_cm_inference_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeICD10CMInferenceJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_phi_detection_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribePhiDetectionJobOutput,
crate::error::DescribePHIDetectionJobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribePHIDetectionJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribePHIDetectionJobError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServerException" => crate::error::DescribePHIDetectionJobError {
meta: generic,
kind: crate::error::DescribePHIDetectionJobErrorKind::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::DescribePHIDetectionJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::DescribePHIDetectionJobError {
meta: generic,
kind: crate::error::DescribePHIDetectionJobErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribePHIDetectionJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribePHIDetectionJobError {
meta: generic,
kind: crate::error::DescribePHIDetectionJobErrorKind::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::DescribePHIDetectionJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::DescribePHIDetectionJobError {
meta: generic,
kind: crate::error::DescribePHIDetectionJobErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribePHIDetectionJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribePHIDetectionJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_phi_detection_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribePhiDetectionJobOutput,
crate::error::DescribePHIDetectionJobError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_phi_detection_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_phi_detection_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribePHIDetectionJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_rx_norm_inference_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeRxNormInferenceJobOutput,
crate::error::DescribeRxNormInferenceJobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeRxNormInferenceJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeRxNormInferenceJobError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServerException" => crate::error::DescribeRxNormInferenceJobError {
meta: generic,
kind: crate::error::DescribeRxNormInferenceJobErrorKind::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::DescribeRxNormInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::DescribeRxNormInferenceJobError {
meta: generic,
kind: crate::error::DescribeRxNormInferenceJobErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeRxNormInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeRxNormInferenceJobError {
meta: generic,
kind: crate::error::DescribeRxNormInferenceJobErrorKind::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::DescribeRxNormInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::DescribeRxNormInferenceJobError {
meta: generic,
kind: crate::error::DescribeRxNormInferenceJobErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeRxNormInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeRxNormInferenceJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_rx_norm_inference_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeRxNormInferenceJobOutput,
crate::error::DescribeRxNormInferenceJobError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_rx_norm_inference_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_rx_norm_inference_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeRxNormInferenceJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_snomedct_inference_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeSnomedctInferenceJobOutput,
crate::error::DescribeSNOMEDCTInferenceJobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeSNOMEDCTInferenceJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeSNOMEDCTInferenceJobError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServerException" => crate::error::DescribeSNOMEDCTInferenceJobError {
meta: generic,
kind: crate::error::DescribeSNOMEDCTInferenceJobErrorKind::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::DescribeSNOMEDCTInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::DescribeSNOMEDCTInferenceJobError {
meta: generic,
kind: crate::error::DescribeSNOMEDCTInferenceJobErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeSNOMEDCTInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeSNOMEDCTInferenceJobError {
meta: generic,
kind: crate::error::DescribeSNOMEDCTInferenceJobErrorKind::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::DescribeSNOMEDCTInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::DescribeSNOMEDCTInferenceJobError {
meta: generic,
kind: crate::error::DescribeSNOMEDCTInferenceJobErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeSNOMEDCTInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeSNOMEDCTInferenceJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_snomedct_inference_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeSnomedctInferenceJobOutput,
crate::error::DescribeSNOMEDCTInferenceJobError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_snomedct_inference_job_output::Builder::default();
let _ = response;
output =
crate::json_deser::deser_operation_crate_operation_describe_snomedct_inference_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeSNOMEDCTInferenceJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_detect_entities_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DetectEntitiesOutput, crate::error::DetectEntitiesError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DetectEntitiesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DetectEntitiesError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServerException" => crate::error::DetectEntitiesError {
meta: generic,
kind: crate::error::DetectEntitiesErrorKind::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::DetectEntitiesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidEncodingException" => crate::error::DetectEntitiesError {
meta: generic,
kind: crate::error::DetectEntitiesErrorKind::InvalidEncodingException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_encoding_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_encoding_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetectEntitiesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::DetectEntitiesError {
meta: generic,
kind: crate::error::DetectEntitiesErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetectEntitiesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::DetectEntitiesError {
meta: generic,
kind: crate::error::DetectEntitiesErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetectEntitiesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TextSizeLimitExceededException" => crate::error::DetectEntitiesError {
meta: generic,
kind: crate::error::DetectEntitiesErrorKind::TextSizeLimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::text_size_limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_text_size_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetectEntitiesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::DetectEntitiesError {
meta: generic,
kind: crate::error::DetectEntitiesErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetectEntitiesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DetectEntitiesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_detect_entities_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DetectEntitiesOutput, crate::error::DetectEntitiesError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::detect_entities_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_detect_entities(
response.body().as_ref(),
output,
)
.map_err(crate::error::DetectEntitiesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_detect_entities_v2_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DetectEntitiesV2Output, crate::error::DetectEntitiesV2Error>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DetectEntitiesV2Error::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DetectEntitiesV2Error::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServerException" => crate::error::DetectEntitiesV2Error {
meta: generic,
kind: crate::error::DetectEntitiesV2ErrorKind::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::DetectEntitiesV2Error::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidEncodingException" => crate::error::DetectEntitiesV2Error {
meta: generic,
kind: crate::error::DetectEntitiesV2ErrorKind::InvalidEncodingException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_encoding_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_encoding_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetectEntitiesV2Error::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::DetectEntitiesV2Error {
meta: generic,
kind: crate::error::DetectEntitiesV2ErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetectEntitiesV2Error::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::DetectEntitiesV2Error {
meta: generic,
kind: crate::error::DetectEntitiesV2ErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetectEntitiesV2Error::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TextSizeLimitExceededException" => crate::error::DetectEntitiesV2Error {
meta: generic,
kind: crate::error::DetectEntitiesV2ErrorKind::TextSizeLimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::text_size_limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_text_size_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetectEntitiesV2Error::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::DetectEntitiesV2Error {
meta: generic,
kind: crate::error::DetectEntitiesV2ErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetectEntitiesV2Error::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DetectEntitiesV2Error::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_detect_entities_v2_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DetectEntitiesV2Output, crate::error::DetectEntitiesV2Error>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::detect_entities_v2_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_detect_entities_v2(
response.body().as_ref(),
output,
)
.map_err(crate::error::DetectEntitiesV2Error::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_detect_phi_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DetectPhiOutput, crate::error::DetectPHIError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DetectPHIError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DetectPHIError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServerException" => crate::error::DetectPHIError {
meta: generic,
kind: crate::error::DetectPHIErrorKind::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::DetectPHIError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidEncodingException" => crate::error::DetectPHIError {
meta: generic,
kind: crate::error::DetectPHIErrorKind::InvalidEncodingException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_encoding_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_encoding_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetectPHIError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::DetectPHIError {
meta: generic,
kind: crate::error::DetectPHIErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetectPHIError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::DetectPHIError {
meta: generic,
kind: crate::error::DetectPHIErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetectPHIError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TextSizeLimitExceededException" => crate::error::DetectPHIError {
meta: generic,
kind: crate::error::DetectPHIErrorKind::TextSizeLimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::text_size_limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_text_size_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetectPHIError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::DetectPHIError {
meta: generic,
kind: crate::error::DetectPHIErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DetectPHIError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DetectPHIError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_detect_phi_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DetectPhiOutput, crate::error::DetectPHIError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::detect_phi_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_detect_phi(
response.body().as_ref(),
output,
)
.map_err(crate::error::DetectPHIError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_infer_icd10_cm_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::InferIcd10CmOutput, crate::error::InferICD10CMError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::InferICD10CMError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::InferICD10CMError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServerException" => crate::error::InferICD10CMError {
meta: generic,
kind: crate::error::InferICD10CMErrorKind::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::InferICD10CMError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidEncodingException" => crate::error::InferICD10CMError {
meta: generic,
kind: crate::error::InferICD10CMErrorKind::InvalidEncodingException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_encoding_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_encoding_exception_json_err(response.body().as_ref(), output).map_err(crate::error::InferICD10CMError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::InferICD10CMError {
meta: generic,
kind: crate::error::InferICD10CMErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::InferICD10CMError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::InferICD10CMError {
meta: generic,
kind: crate::error::InferICD10CMErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::InferICD10CMError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TextSizeLimitExceededException" => crate::error::InferICD10CMError {
meta: generic,
kind: crate::error::InferICD10CMErrorKind::TextSizeLimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::text_size_limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_text_size_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::InferICD10CMError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::InferICD10CMError {
meta: generic,
kind: crate::error::InferICD10CMErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::InferICD10CMError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::InferICD10CMError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_infer_icd10_cm_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::InferIcd10CmOutput, crate::error::InferICD10CMError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::infer_icd10_cm_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_infer_icd10_cm(
response.body().as_ref(),
output,
)
.map_err(crate::error::InferICD10CMError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_infer_rx_norm_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::InferRxNormOutput, crate::error::InferRxNormError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::InferRxNormError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::InferRxNormError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServerException" => crate::error::InferRxNormError {
meta: generic,
kind: crate::error::InferRxNormErrorKind::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::InferRxNormError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidEncodingException" => crate::error::InferRxNormError {
meta: generic,
kind: crate::error::InferRxNormErrorKind::InvalidEncodingException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_encoding_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_encoding_exception_json_err(response.body().as_ref(), output).map_err(crate::error::InferRxNormError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::InferRxNormError {
meta: generic,
kind: crate::error::InferRxNormErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::InferRxNormError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::InferRxNormError {
meta: generic,
kind: crate::error::InferRxNormErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::InferRxNormError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TextSizeLimitExceededException" => crate::error::InferRxNormError {
meta: generic,
kind: crate::error::InferRxNormErrorKind::TextSizeLimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::text_size_limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_text_size_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::InferRxNormError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::InferRxNormError {
meta: generic,
kind: crate::error::InferRxNormErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::InferRxNormError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::InferRxNormError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_infer_rx_norm_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::InferRxNormOutput, crate::error::InferRxNormError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::infer_rx_norm_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_infer_rx_norm(
response.body().as_ref(),
output,
)
.map_err(crate::error::InferRxNormError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_infer_snomedct_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::InferSnomedctOutput, crate::error::InferSNOMEDCTError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::InferSNOMEDCTError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::InferSNOMEDCTError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServerException" => crate::error::InferSNOMEDCTError {
meta: generic,
kind: crate::error::InferSNOMEDCTErrorKind::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::InferSNOMEDCTError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidEncodingException" => crate::error::InferSNOMEDCTError {
meta: generic,
kind: crate::error::InferSNOMEDCTErrorKind::InvalidEncodingException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_encoding_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_encoding_exception_json_err(response.body().as_ref(), output).map_err(crate::error::InferSNOMEDCTError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::InferSNOMEDCTError {
meta: generic,
kind: crate::error::InferSNOMEDCTErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::InferSNOMEDCTError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::InferSNOMEDCTError {
meta: generic,
kind: crate::error::InferSNOMEDCTErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::InferSNOMEDCTError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TextSizeLimitExceededException" => crate::error::InferSNOMEDCTError {
meta: generic,
kind: crate::error::InferSNOMEDCTErrorKind::TextSizeLimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::text_size_limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_text_size_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::InferSNOMEDCTError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::InferSNOMEDCTError {
meta: generic,
kind: crate::error::InferSNOMEDCTErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::InferSNOMEDCTError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::InferSNOMEDCTError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_infer_snomedct_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::InferSnomedctOutput, crate::error::InferSNOMEDCTError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::infer_snomedct_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_infer_snomedct(
response.body().as_ref(),
output,
)
.map_err(crate::error::InferSNOMEDCTError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_entities_detection_v2_jobs_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListEntitiesDetectionV2JobsOutput,
crate::error::ListEntitiesDetectionV2JobsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListEntitiesDetectionV2JobsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListEntitiesDetectionV2JobsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServerException" => crate::error::ListEntitiesDetectionV2JobsError {
meta: generic,
kind: crate::error::ListEntitiesDetectionV2JobsErrorKind::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::ListEntitiesDetectionV2JobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::ListEntitiesDetectionV2JobsError {
meta: generic,
kind: crate::error::ListEntitiesDetectionV2JobsErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListEntitiesDetectionV2JobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::ListEntitiesDetectionV2JobsError {
meta: generic,
kind: crate::error::ListEntitiesDetectionV2JobsErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListEntitiesDetectionV2JobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::ListEntitiesDetectionV2JobsError {
meta: generic,
kind: crate::error::ListEntitiesDetectionV2JobsErrorKind::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::ListEntitiesDetectionV2JobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListEntitiesDetectionV2JobsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_entities_detection_v2_jobs_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListEntitiesDetectionV2JobsOutput,
crate::error::ListEntitiesDetectionV2JobsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_entities_detection_v2_jobs_output::Builder::default();
let _ = response;
output =
crate::json_deser::deser_operation_crate_operation_list_entities_detection_v2_jobs(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListEntitiesDetectionV2JobsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_icd10_cm_inference_jobs_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListIcd10CmInferenceJobsOutput,
crate::error::ListICD10CMInferenceJobsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListICD10CMInferenceJobsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListICD10CMInferenceJobsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServerException" => crate::error::ListICD10CMInferenceJobsError {
meta: generic,
kind: crate::error::ListICD10CMInferenceJobsErrorKind::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::ListICD10CMInferenceJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::ListICD10CMInferenceJobsError {
meta: generic,
kind: crate::error::ListICD10CMInferenceJobsErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListICD10CMInferenceJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::ListICD10CMInferenceJobsError {
meta: generic,
kind: crate::error::ListICD10CMInferenceJobsErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListICD10CMInferenceJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::ListICD10CMInferenceJobsError {
meta: generic,
kind: crate::error::ListICD10CMInferenceJobsErrorKind::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::ListICD10CMInferenceJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListICD10CMInferenceJobsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_icd10_cm_inference_jobs_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListIcd10CmInferenceJobsOutput,
crate::error::ListICD10CMInferenceJobsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_icd10_cm_inference_jobs_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_icd10_cm_inference_jobs(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListICD10CMInferenceJobsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_phi_detection_jobs_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListPhiDetectionJobsOutput,
crate::error::ListPHIDetectionJobsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListPHIDetectionJobsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListPHIDetectionJobsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServerException" => crate::error::ListPHIDetectionJobsError {
meta: generic,
kind: crate::error::ListPHIDetectionJobsErrorKind::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::ListPHIDetectionJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::ListPHIDetectionJobsError {
meta: generic,
kind: crate::error::ListPHIDetectionJobsErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListPHIDetectionJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::ListPHIDetectionJobsError {
meta: generic,
kind: crate::error::ListPHIDetectionJobsErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListPHIDetectionJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::ListPHIDetectionJobsError {
meta: generic,
kind: crate::error::ListPHIDetectionJobsErrorKind::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::ListPHIDetectionJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListPHIDetectionJobsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_phi_detection_jobs_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListPhiDetectionJobsOutput,
crate::error::ListPHIDetectionJobsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_phi_detection_jobs_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_phi_detection_jobs(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListPHIDetectionJobsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_rx_norm_inference_jobs_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListRxNormInferenceJobsOutput,
crate::error::ListRxNormInferenceJobsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListRxNormInferenceJobsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListRxNormInferenceJobsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServerException" => crate::error::ListRxNormInferenceJobsError {
meta: generic,
kind: crate::error::ListRxNormInferenceJobsErrorKind::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::ListRxNormInferenceJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::ListRxNormInferenceJobsError {
meta: generic,
kind: crate::error::ListRxNormInferenceJobsErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListRxNormInferenceJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::ListRxNormInferenceJobsError {
meta: generic,
kind: crate::error::ListRxNormInferenceJobsErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListRxNormInferenceJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::ListRxNormInferenceJobsError {
meta: generic,
kind: crate::error::ListRxNormInferenceJobsErrorKind::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::ListRxNormInferenceJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListRxNormInferenceJobsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_rx_norm_inference_jobs_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListRxNormInferenceJobsOutput,
crate::error::ListRxNormInferenceJobsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_rx_norm_inference_jobs_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_rx_norm_inference_jobs(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListRxNormInferenceJobsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_snomedct_inference_jobs_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListSnomedctInferenceJobsOutput,
crate::error::ListSNOMEDCTInferenceJobsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListSNOMEDCTInferenceJobsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListSNOMEDCTInferenceJobsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServerException" => crate::error::ListSNOMEDCTInferenceJobsError {
meta: generic,
kind: crate::error::ListSNOMEDCTInferenceJobsErrorKind::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::ListSNOMEDCTInferenceJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::ListSNOMEDCTInferenceJobsError {
meta: generic,
kind: crate::error::ListSNOMEDCTInferenceJobsErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListSNOMEDCTInferenceJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::ListSNOMEDCTInferenceJobsError {
meta: generic,
kind: crate::error::ListSNOMEDCTInferenceJobsErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListSNOMEDCTInferenceJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::ListSNOMEDCTInferenceJobsError {
meta: generic,
kind: crate::error::ListSNOMEDCTInferenceJobsErrorKind::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::ListSNOMEDCTInferenceJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListSNOMEDCTInferenceJobsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_snomedct_inference_jobs_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListSnomedctInferenceJobsOutput,
crate::error::ListSNOMEDCTInferenceJobsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_snomedct_inference_jobs_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_snomedct_inference_jobs(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListSNOMEDCTInferenceJobsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_entities_detection_v2_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::StartEntitiesDetectionV2JobOutput,
crate::error::StartEntitiesDetectionV2JobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StartEntitiesDetectionV2JobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::StartEntitiesDetectionV2JobError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServerException" => crate::error::StartEntitiesDetectionV2JobError {
meta: generic,
kind: crate::error::StartEntitiesDetectionV2JobErrorKind::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::StartEntitiesDetectionV2JobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::StartEntitiesDetectionV2JobError {
meta: generic,
kind: crate::error::StartEntitiesDetectionV2JobErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartEntitiesDetectionV2JobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::StartEntitiesDetectionV2JobError {
meta: generic,
kind: crate::error::StartEntitiesDetectionV2JobErrorKind::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::StartEntitiesDetectionV2JobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::StartEntitiesDetectionV2JobError {
meta: generic,
kind: crate::error::StartEntitiesDetectionV2JobErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartEntitiesDetectionV2JobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::StartEntitiesDetectionV2JobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_entities_detection_v2_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::StartEntitiesDetectionV2JobOutput,
crate::error::StartEntitiesDetectionV2JobError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::start_entities_detection_v2_job_output::Builder::default();
let _ = response;
output =
crate::json_deser::deser_operation_crate_operation_start_entities_detection_v2_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::StartEntitiesDetectionV2JobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_icd10_cm_inference_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::StartIcd10CmInferenceJobOutput,
crate::error::StartICD10CMInferenceJobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StartICD10CMInferenceJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::StartICD10CMInferenceJobError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServerException" => crate::error::StartICD10CMInferenceJobError {
meta: generic,
kind: crate::error::StartICD10CMInferenceJobErrorKind::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::StartICD10CMInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::StartICD10CMInferenceJobError {
meta: generic,
kind: crate::error::StartICD10CMInferenceJobErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartICD10CMInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::StartICD10CMInferenceJobError {
meta: generic,
kind: crate::error::StartICD10CMInferenceJobErrorKind::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::StartICD10CMInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::StartICD10CMInferenceJobError {
meta: generic,
kind: crate::error::StartICD10CMInferenceJobErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartICD10CMInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::StartICD10CMInferenceJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_icd10_cm_inference_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::StartIcd10CmInferenceJobOutput,
crate::error::StartICD10CMInferenceJobError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::start_icd10_cm_inference_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_start_icd10_cm_inference_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::StartICD10CMInferenceJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_phi_detection_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::StartPhiDetectionJobOutput,
crate::error::StartPHIDetectionJobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StartPHIDetectionJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::StartPHIDetectionJobError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServerException" => crate::error::StartPHIDetectionJobError {
meta: generic,
kind: crate::error::StartPHIDetectionJobErrorKind::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::StartPHIDetectionJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::StartPHIDetectionJobError {
meta: generic,
kind: crate::error::StartPHIDetectionJobErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartPHIDetectionJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::StartPHIDetectionJobError {
meta: generic,
kind: crate::error::StartPHIDetectionJobErrorKind::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::StartPHIDetectionJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::StartPHIDetectionJobError {
meta: generic,
kind: crate::error::StartPHIDetectionJobErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartPHIDetectionJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::StartPHIDetectionJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_phi_detection_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::StartPhiDetectionJobOutput,
crate::error::StartPHIDetectionJobError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::start_phi_detection_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_start_phi_detection_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::StartPHIDetectionJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_rx_norm_inference_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::StartRxNormInferenceJobOutput,
crate::error::StartRxNormInferenceJobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StartRxNormInferenceJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::StartRxNormInferenceJobError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServerException" => crate::error::StartRxNormInferenceJobError {
meta: generic,
kind: crate::error::StartRxNormInferenceJobErrorKind::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::StartRxNormInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::StartRxNormInferenceJobError {
meta: generic,
kind: crate::error::StartRxNormInferenceJobErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartRxNormInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::StartRxNormInferenceJobError {
meta: generic,
kind: crate::error::StartRxNormInferenceJobErrorKind::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::StartRxNormInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::StartRxNormInferenceJobError {
meta: generic,
kind: crate::error::StartRxNormInferenceJobErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartRxNormInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::StartRxNormInferenceJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_rx_norm_inference_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::StartRxNormInferenceJobOutput,
crate::error::StartRxNormInferenceJobError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::start_rx_norm_inference_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_start_rx_norm_inference_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::StartRxNormInferenceJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_snomedct_inference_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::StartSnomedctInferenceJobOutput,
crate::error::StartSNOMEDCTInferenceJobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StartSNOMEDCTInferenceJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::StartSNOMEDCTInferenceJobError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServerException" => crate::error::StartSNOMEDCTInferenceJobError {
meta: generic,
kind: crate::error::StartSNOMEDCTInferenceJobErrorKind::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::StartSNOMEDCTInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::StartSNOMEDCTInferenceJobError {
meta: generic,
kind: crate::error::StartSNOMEDCTInferenceJobErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartSNOMEDCTInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::StartSNOMEDCTInferenceJobError {
meta: generic,
kind: crate::error::StartSNOMEDCTInferenceJobErrorKind::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::StartSNOMEDCTInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::StartSNOMEDCTInferenceJobError {
meta: generic,
kind: crate::error::StartSNOMEDCTInferenceJobErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartSNOMEDCTInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::StartSNOMEDCTInferenceJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_snomedct_inference_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::StartSnomedctInferenceJobOutput,
crate::error::StartSNOMEDCTInferenceJobError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::start_snomedct_inference_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_start_snomedct_inference_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::StartSNOMEDCTInferenceJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_entities_detection_v2_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::StopEntitiesDetectionV2JobOutput,
crate::error::StopEntitiesDetectionV2JobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StopEntitiesDetectionV2JobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::StopEntitiesDetectionV2JobError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServerException" => crate::error::StopEntitiesDetectionV2JobError {
meta: generic,
kind: crate::error::StopEntitiesDetectionV2JobErrorKind::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::StopEntitiesDetectionV2JobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::StopEntitiesDetectionV2JobError {
meta: generic,
kind: crate::error::StopEntitiesDetectionV2JobErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopEntitiesDetectionV2JobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::StopEntitiesDetectionV2JobError {
meta: generic,
kind: crate::error::StopEntitiesDetectionV2JobErrorKind::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::StopEntitiesDetectionV2JobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::StopEntitiesDetectionV2JobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_entities_detection_v2_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::StopEntitiesDetectionV2JobOutput,
crate::error::StopEntitiesDetectionV2JobError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::stop_entities_detection_v2_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_stop_entities_detection_v2_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::StopEntitiesDetectionV2JobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_icd10_cm_inference_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::StopIcd10CmInferenceJobOutput,
crate::error::StopICD10CMInferenceJobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StopICD10CMInferenceJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::StopICD10CMInferenceJobError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServerException" => crate::error::StopICD10CMInferenceJobError {
meta: generic,
kind: crate::error::StopICD10CMInferenceJobErrorKind::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::StopICD10CMInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::StopICD10CMInferenceJobError {
meta: generic,
kind: crate::error::StopICD10CMInferenceJobErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopICD10CMInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::StopICD10CMInferenceJobError {
meta: generic,
kind: crate::error::StopICD10CMInferenceJobErrorKind::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::StopICD10CMInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::StopICD10CMInferenceJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_icd10_cm_inference_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::StopIcd10CmInferenceJobOutput,
crate::error::StopICD10CMInferenceJobError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::stop_icd10_cm_inference_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_stop_icd10_cm_inference_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::StopICD10CMInferenceJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_phi_detection_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::StopPhiDetectionJobOutput,
crate::error::StopPHIDetectionJobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StopPHIDetectionJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::StopPHIDetectionJobError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServerException" => crate::error::StopPHIDetectionJobError {
meta: generic,
kind: crate::error::StopPHIDetectionJobErrorKind::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::StopPHIDetectionJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::StopPHIDetectionJobError {
meta: generic,
kind: crate::error::StopPHIDetectionJobErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopPHIDetectionJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::StopPHIDetectionJobError {
meta: generic,
kind: crate::error::StopPHIDetectionJobErrorKind::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::StopPHIDetectionJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::StopPHIDetectionJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_phi_detection_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::StopPhiDetectionJobOutput,
crate::error::StopPHIDetectionJobError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::stop_phi_detection_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_stop_phi_detection_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::StopPHIDetectionJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_rx_norm_inference_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::StopRxNormInferenceJobOutput,
crate::error::StopRxNormInferenceJobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StopRxNormInferenceJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::StopRxNormInferenceJobError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServerException" => crate::error::StopRxNormInferenceJobError {
meta: generic,
kind: crate::error::StopRxNormInferenceJobErrorKind::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::StopRxNormInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::StopRxNormInferenceJobError {
meta: generic,
kind: crate::error::StopRxNormInferenceJobErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopRxNormInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::StopRxNormInferenceJobError {
meta: generic,
kind: crate::error::StopRxNormInferenceJobErrorKind::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::StopRxNormInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::StopRxNormInferenceJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_rx_norm_inference_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::StopRxNormInferenceJobOutput,
crate::error::StopRxNormInferenceJobError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::stop_rx_norm_inference_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_stop_rx_norm_inference_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::StopRxNormInferenceJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_snomedct_inference_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::StopSnomedctInferenceJobOutput,
crate::error::StopSNOMEDCTInferenceJobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StopSNOMEDCTInferenceJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::StopSNOMEDCTInferenceJobError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InternalServerException" => crate::error::StopSNOMEDCTInferenceJobError {
meta: generic,
kind: crate::error::StopSNOMEDCTInferenceJobErrorKind::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::StopSNOMEDCTInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::StopSNOMEDCTInferenceJobError {
meta: generic,
kind: crate::error::StopSNOMEDCTInferenceJobErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopSNOMEDCTInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::StopSNOMEDCTInferenceJobError {
meta: generic,
kind: crate::error::StopSNOMEDCTInferenceJobErrorKind::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::StopSNOMEDCTInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::StopSNOMEDCTInferenceJobError {
meta: generic,
kind: crate::error::StopSNOMEDCTInferenceJobErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopSNOMEDCTInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::StopSNOMEDCTInferenceJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_snomedct_inference_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::StopSnomedctInferenceJobOutput,
crate::error::StopSNOMEDCTInferenceJobError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::stop_snomedct_inference_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_stop_snomedct_inference_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::StopSNOMEDCTInferenceJobError::unhandled)?;
output.build()
})
}