use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::proto;
use rusoto_core::request::HttpResponse;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
impl ComprehendMedicalClient {
fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
let mut request =
SignedRequest::new(http_method, "comprehendmedical", &self.region, request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request
}
async fn sign_and_dispatch<E>(
&self,
request: SignedRequest,
from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
) -> Result<HttpResponse, RusotoError<E>> {
let mut response = self.client.sign_and_dispatch(request).await?;
if !response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
return Err(from_response(response));
}
Ok(response)
}
}
use serde_json;
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Attribute {
#[serde(rename = "BeginOffset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub begin_offset: Option<i64>,
#[serde(rename = "Category")]
#[serde(skip_serializing_if = "Option::is_none")]
pub category: Option<String>,
#[serde(rename = "EndOffset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_offset: Option<i64>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<i64>,
#[serde(rename = "RelationshipScore")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relationship_score: Option<f32>,
#[serde(rename = "RelationshipType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relationship_type: Option<String>,
#[serde(rename = "Score")]
#[serde(skip_serializing_if = "Option::is_none")]
pub score: Option<f32>,
#[serde(rename = "Text")]
#[serde(skip_serializing_if = "Option::is_none")]
pub text: Option<String>,
#[serde(rename = "Traits")]
#[serde(skip_serializing_if = "Option::is_none")]
pub traits: Option<Vec<Trait>>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ComprehendMedicalAsyncJobFilter {
#[serde(rename = "JobName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_name: Option<String>,
#[serde(rename = "JobStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_status: Option<String>,
#[serde(rename = "SubmitTimeAfter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub submit_time_after: Option<f64>,
#[serde(rename = "SubmitTimeBefore")]
#[serde(skip_serializing_if = "Option::is_none")]
pub submit_time_before: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ComprehendMedicalAsyncJobProperties {
#[serde(rename = "DataAccessRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_access_role_arn: Option<String>,
#[serde(rename = "EndTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_time: Option<f64>,
#[serde(rename = "ExpirationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expiration_time: Option<f64>,
#[serde(rename = "InputDataConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_data_config: Option<InputDataConfig>,
#[serde(rename = "JobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_id: Option<String>,
#[serde(rename = "JobName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_name: Option<String>,
#[serde(rename = "JobStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_status: Option<String>,
#[serde(rename = "KMSKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key: Option<String>,
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "ManifestFilePath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub manifest_file_path: Option<String>,
#[serde(rename = "Message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(rename = "ModelVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model_version: Option<String>,
#[serde(rename = "OutputDataConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_data_config: Option<OutputDataConfig>,
#[serde(rename = "SubmitTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub submit_time: Option<f64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeEntitiesDetectionV2JobRequest {
#[serde(rename = "JobId")]
pub job_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeEntitiesDetectionV2JobResponse {
#[serde(rename = "ComprehendMedicalAsyncJobProperties")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comprehend_medical_async_job_properties: Option<ComprehendMedicalAsyncJobProperties>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeICD10CMInferenceJobRequest {
#[serde(rename = "JobId")]
pub job_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeICD10CMInferenceJobResponse {
#[serde(rename = "ComprehendMedicalAsyncJobProperties")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comprehend_medical_async_job_properties: Option<ComprehendMedicalAsyncJobProperties>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribePHIDetectionJobRequest {
#[serde(rename = "JobId")]
pub job_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribePHIDetectionJobResponse {
#[serde(rename = "ComprehendMedicalAsyncJobProperties")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comprehend_medical_async_job_properties: Option<ComprehendMedicalAsyncJobProperties>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeRxNormInferenceJobRequest {
#[serde(rename = "JobId")]
pub job_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeRxNormInferenceJobResponse {
#[serde(rename = "ComprehendMedicalAsyncJobProperties")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comprehend_medical_async_job_properties: Option<ComprehendMedicalAsyncJobProperties>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DetectEntitiesRequest {
#[serde(rename = "Text")]
pub text: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DetectEntitiesResponse {
#[serde(rename = "Entities")]
pub entities: Vec<Entity>,
#[serde(rename = "ModelVersion")]
pub model_version: String,
#[serde(rename = "PaginationToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pagination_token: Option<String>,
#[serde(rename = "UnmappedAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unmapped_attributes: Option<Vec<UnmappedAttribute>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DetectEntitiesV2Request {
#[serde(rename = "Text")]
pub text: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DetectEntitiesV2Response {
#[serde(rename = "Entities")]
pub entities: Vec<Entity>,
#[serde(rename = "ModelVersion")]
pub model_version: String,
#[serde(rename = "PaginationToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pagination_token: Option<String>,
#[serde(rename = "UnmappedAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unmapped_attributes: Option<Vec<UnmappedAttribute>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DetectPHIRequest {
#[serde(rename = "Text")]
pub text: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DetectPHIResponse {
#[serde(rename = "Entities")]
pub entities: Vec<Entity>,
#[serde(rename = "ModelVersion")]
pub model_version: String,
#[serde(rename = "PaginationToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pagination_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Entity {
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<Vec<Attribute>>,
#[serde(rename = "BeginOffset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub begin_offset: Option<i64>,
#[serde(rename = "Category")]
#[serde(skip_serializing_if = "Option::is_none")]
pub category: Option<String>,
#[serde(rename = "EndOffset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_offset: Option<i64>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<i64>,
#[serde(rename = "Score")]
#[serde(skip_serializing_if = "Option::is_none")]
pub score: Option<f32>,
#[serde(rename = "Text")]
#[serde(skip_serializing_if = "Option::is_none")]
pub text: Option<String>,
#[serde(rename = "Traits")]
#[serde(skip_serializing_if = "Option::is_none")]
pub traits: Option<Vec<Trait>>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ICD10CMAttribute {
#[serde(rename = "BeginOffset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub begin_offset: Option<i64>,
#[serde(rename = "EndOffset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_offset: Option<i64>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<i64>,
#[serde(rename = "RelationshipScore")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relationship_score: Option<f32>,
#[serde(rename = "Score")]
#[serde(skip_serializing_if = "Option::is_none")]
pub score: Option<f32>,
#[serde(rename = "Text")]
#[serde(skip_serializing_if = "Option::is_none")]
pub text: Option<String>,
#[serde(rename = "Traits")]
#[serde(skip_serializing_if = "Option::is_none")]
pub traits: Option<Vec<ICD10CMTrait>>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ICD10CMConcept {
#[serde(rename = "Code")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Score")]
#[serde(skip_serializing_if = "Option::is_none")]
pub score: Option<f32>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ICD10CMEntity {
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<Vec<ICD10CMAttribute>>,
#[serde(rename = "BeginOffset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub begin_offset: Option<i64>,
#[serde(rename = "Category")]
#[serde(skip_serializing_if = "Option::is_none")]
pub category: Option<String>,
#[serde(rename = "EndOffset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_offset: Option<i64>,
#[serde(rename = "ICD10CMConcepts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub icd10cm_concepts: Option<Vec<ICD10CMConcept>>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<i64>,
#[serde(rename = "Score")]
#[serde(skip_serializing_if = "Option::is_none")]
pub score: Option<f32>,
#[serde(rename = "Text")]
#[serde(skip_serializing_if = "Option::is_none")]
pub text: Option<String>,
#[serde(rename = "Traits")]
#[serde(skip_serializing_if = "Option::is_none")]
pub traits: Option<Vec<ICD10CMTrait>>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ICD10CMTrait {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Score")]
#[serde(skip_serializing_if = "Option::is_none")]
pub score: Option<f32>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct InferICD10CMRequest {
#[serde(rename = "Text")]
pub text: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InferICD10CMResponse {
#[serde(rename = "Entities")]
pub entities: Vec<ICD10CMEntity>,
#[serde(rename = "ModelVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model_version: Option<String>,
#[serde(rename = "PaginationToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pagination_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct InferRxNormRequest {
#[serde(rename = "Text")]
pub text: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InferRxNormResponse {
#[serde(rename = "Entities")]
pub entities: Vec<RxNormEntity>,
#[serde(rename = "ModelVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model_version: Option<String>,
#[serde(rename = "PaginationToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pagination_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct InputDataConfig {
#[serde(rename = "S3Bucket")]
pub s3_bucket: String,
#[serde(rename = "S3Key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_key: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListEntitiesDetectionV2JobsRequest {
#[serde(rename = "Filter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter: Option<ComprehendMedicalAsyncJobFilter>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListEntitiesDetectionV2JobsResponse {
#[serde(rename = "ComprehendMedicalAsyncJobPropertiesList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comprehend_medical_async_job_properties_list:
Option<Vec<ComprehendMedicalAsyncJobProperties>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListICD10CMInferenceJobsRequest {
#[serde(rename = "Filter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter: Option<ComprehendMedicalAsyncJobFilter>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListICD10CMInferenceJobsResponse {
#[serde(rename = "ComprehendMedicalAsyncJobPropertiesList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comprehend_medical_async_job_properties_list:
Option<Vec<ComprehendMedicalAsyncJobProperties>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListPHIDetectionJobsRequest {
#[serde(rename = "Filter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter: Option<ComprehendMedicalAsyncJobFilter>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListPHIDetectionJobsResponse {
#[serde(rename = "ComprehendMedicalAsyncJobPropertiesList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comprehend_medical_async_job_properties_list:
Option<Vec<ComprehendMedicalAsyncJobProperties>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListRxNormInferenceJobsRequest {
#[serde(rename = "Filter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter: Option<ComprehendMedicalAsyncJobFilter>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListRxNormInferenceJobsResponse {
#[serde(rename = "ComprehendMedicalAsyncJobPropertiesList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comprehend_medical_async_job_properties_list:
Option<Vec<ComprehendMedicalAsyncJobProperties>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct OutputDataConfig {
#[serde(rename = "S3Bucket")]
pub s3_bucket: String,
#[serde(rename = "S3Key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_key: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RxNormAttribute {
#[serde(rename = "BeginOffset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub begin_offset: Option<i64>,
#[serde(rename = "EndOffset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_offset: Option<i64>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<i64>,
#[serde(rename = "RelationshipScore")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relationship_score: Option<f32>,
#[serde(rename = "Score")]
#[serde(skip_serializing_if = "Option::is_none")]
pub score: Option<f32>,
#[serde(rename = "Text")]
#[serde(skip_serializing_if = "Option::is_none")]
pub text: Option<String>,
#[serde(rename = "Traits")]
#[serde(skip_serializing_if = "Option::is_none")]
pub traits: Option<Vec<RxNormTrait>>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RxNormConcept {
#[serde(rename = "Code")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Score")]
#[serde(skip_serializing_if = "Option::is_none")]
pub score: Option<f32>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RxNormEntity {
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<Vec<RxNormAttribute>>,
#[serde(rename = "BeginOffset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub begin_offset: Option<i64>,
#[serde(rename = "Category")]
#[serde(skip_serializing_if = "Option::is_none")]
pub category: Option<String>,
#[serde(rename = "EndOffset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_offset: Option<i64>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<i64>,
#[serde(rename = "RxNormConcepts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rx_norm_concepts: Option<Vec<RxNormConcept>>,
#[serde(rename = "Score")]
#[serde(skip_serializing_if = "Option::is_none")]
pub score: Option<f32>,
#[serde(rename = "Text")]
#[serde(skip_serializing_if = "Option::is_none")]
pub text: Option<String>,
#[serde(rename = "Traits")]
#[serde(skip_serializing_if = "Option::is_none")]
pub traits: Option<Vec<RxNormTrait>>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RxNormTrait {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Score")]
#[serde(skip_serializing_if = "Option::is_none")]
pub score: Option<f32>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartEntitiesDetectionV2JobRequest {
#[serde(rename = "ClientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "DataAccessRoleArn")]
pub data_access_role_arn: String,
#[serde(rename = "InputDataConfig")]
pub input_data_config: InputDataConfig,
#[serde(rename = "JobName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_name: Option<String>,
#[serde(rename = "KMSKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key: Option<String>,
#[serde(rename = "LanguageCode")]
pub language_code: String,
#[serde(rename = "OutputDataConfig")]
pub output_data_config: OutputDataConfig,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartEntitiesDetectionV2JobResponse {
#[serde(rename = "JobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartICD10CMInferenceJobRequest {
#[serde(rename = "ClientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "DataAccessRoleArn")]
pub data_access_role_arn: String,
#[serde(rename = "InputDataConfig")]
pub input_data_config: InputDataConfig,
#[serde(rename = "JobName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_name: Option<String>,
#[serde(rename = "KMSKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key: Option<String>,
#[serde(rename = "LanguageCode")]
pub language_code: String,
#[serde(rename = "OutputDataConfig")]
pub output_data_config: OutputDataConfig,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartICD10CMInferenceJobResponse {
#[serde(rename = "JobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartPHIDetectionJobRequest {
#[serde(rename = "ClientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "DataAccessRoleArn")]
pub data_access_role_arn: String,
#[serde(rename = "InputDataConfig")]
pub input_data_config: InputDataConfig,
#[serde(rename = "JobName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_name: Option<String>,
#[serde(rename = "KMSKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key: Option<String>,
#[serde(rename = "LanguageCode")]
pub language_code: String,
#[serde(rename = "OutputDataConfig")]
pub output_data_config: OutputDataConfig,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartPHIDetectionJobResponse {
#[serde(rename = "JobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartRxNormInferenceJobRequest {
#[serde(rename = "ClientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "DataAccessRoleArn")]
pub data_access_role_arn: String,
#[serde(rename = "InputDataConfig")]
pub input_data_config: InputDataConfig,
#[serde(rename = "JobName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_name: Option<String>,
#[serde(rename = "KMSKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key: Option<String>,
#[serde(rename = "LanguageCode")]
pub language_code: String,
#[serde(rename = "OutputDataConfig")]
pub output_data_config: OutputDataConfig,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartRxNormInferenceJobResponse {
#[serde(rename = "JobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopEntitiesDetectionV2JobRequest {
#[serde(rename = "JobId")]
pub job_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StopEntitiesDetectionV2JobResponse {
#[serde(rename = "JobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopICD10CMInferenceJobRequest {
#[serde(rename = "JobId")]
pub job_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StopICD10CMInferenceJobResponse {
#[serde(rename = "JobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopPHIDetectionJobRequest {
#[serde(rename = "JobId")]
pub job_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StopPHIDetectionJobResponse {
#[serde(rename = "JobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopRxNormInferenceJobRequest {
#[serde(rename = "JobId")]
pub job_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StopRxNormInferenceJobResponse {
#[serde(rename = "JobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Trait {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Score")]
#[serde(skip_serializing_if = "Option::is_none")]
pub score: Option<f32>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UnmappedAttribute {
#[serde(rename = "Attribute")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attribute: Option<Attribute>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum DescribeEntitiesDetectionV2JobError {
InternalServer(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl DescribeEntitiesDetectionV2JobError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeEntitiesDetectionV2JobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(
DescribeEntitiesDetectionV2JobError::InternalServer(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
DescribeEntitiesDetectionV2JobError::InvalidRequest(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DescribeEntitiesDetectionV2JobError::ResourceNotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
DescribeEntitiesDetectionV2JobError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeEntitiesDetectionV2JobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeEntitiesDetectionV2JobError::InternalServer(ref cause) => {
write!(f, "{}", cause)
}
DescribeEntitiesDetectionV2JobError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
DescribeEntitiesDetectionV2JobError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
DescribeEntitiesDetectionV2JobError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeEntitiesDetectionV2JobError {}
#[derive(Debug, PartialEq)]
pub enum DescribeICD10CMInferenceJobError {
InternalServer(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl DescribeICD10CMInferenceJobError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeICD10CMInferenceJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DescribeICD10CMInferenceJobError::InternalServer(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(DescribeICD10CMInferenceJobError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DescribeICD10CMInferenceJobError::ResourceNotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(DescribeICD10CMInferenceJobError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeICD10CMInferenceJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeICD10CMInferenceJobError::InternalServer(ref cause) => write!(f, "{}", cause),
DescribeICD10CMInferenceJobError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DescribeICD10CMInferenceJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeICD10CMInferenceJobError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeICD10CMInferenceJobError {}
#[derive(Debug, PartialEq)]
pub enum DescribePHIDetectionJobError {
InternalServer(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl DescribePHIDetectionJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribePHIDetectionJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DescribePHIDetectionJobError::InternalServer(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(DescribePHIDetectionJobError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribePHIDetectionJobError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(DescribePHIDetectionJobError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribePHIDetectionJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribePHIDetectionJobError::InternalServer(ref cause) => write!(f, "{}", cause),
DescribePHIDetectionJobError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DescribePHIDetectionJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribePHIDetectionJobError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribePHIDetectionJobError {}
#[derive(Debug, PartialEq)]
pub enum DescribeRxNormInferenceJobError {
InternalServer(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl DescribeRxNormInferenceJobError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeRxNormInferenceJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DescribeRxNormInferenceJobError::InternalServer(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(DescribeRxNormInferenceJobError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeRxNormInferenceJobError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(DescribeRxNormInferenceJobError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeRxNormInferenceJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeRxNormInferenceJobError::InternalServer(ref cause) => write!(f, "{}", cause),
DescribeRxNormInferenceJobError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DescribeRxNormInferenceJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeRxNormInferenceJobError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeRxNormInferenceJobError {}
#[derive(Debug, PartialEq)]
pub enum DetectEntitiesError {
InternalServer(String),
InvalidEncoding(String),
InvalidRequest(String),
ServiceUnavailable(String),
TextSizeLimitExceeded(String),
TooManyRequests(String),
}
impl DetectEntitiesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DetectEntitiesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DetectEntitiesError::InternalServer(err.msg))
}
"InvalidEncodingException" => {
return RusotoError::Service(DetectEntitiesError::InvalidEncoding(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DetectEntitiesError::InvalidRequest(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DetectEntitiesError::ServiceUnavailable(err.msg))
}
"TextSizeLimitExceededException" => {
return RusotoError::Service(DetectEntitiesError::TextSizeLimitExceeded(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(DetectEntitiesError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DetectEntitiesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DetectEntitiesError::InternalServer(ref cause) => write!(f, "{}", cause),
DetectEntitiesError::InvalidEncoding(ref cause) => write!(f, "{}", cause),
DetectEntitiesError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DetectEntitiesError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
DetectEntitiesError::TextSizeLimitExceeded(ref cause) => write!(f, "{}", cause),
DetectEntitiesError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DetectEntitiesError {}
#[derive(Debug, PartialEq)]
pub enum DetectEntitiesV2Error {
InternalServer(String),
InvalidEncoding(String),
InvalidRequest(String),
ServiceUnavailable(String),
TextSizeLimitExceeded(String),
TooManyRequests(String),
}
impl DetectEntitiesV2Error {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DetectEntitiesV2Error> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DetectEntitiesV2Error::InternalServer(err.msg))
}
"InvalidEncodingException" => {
return RusotoError::Service(DetectEntitiesV2Error::InvalidEncoding(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DetectEntitiesV2Error::InvalidRequest(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DetectEntitiesV2Error::ServiceUnavailable(err.msg))
}
"TextSizeLimitExceededException" => {
return RusotoError::Service(DetectEntitiesV2Error::TextSizeLimitExceeded(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(DetectEntitiesV2Error::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DetectEntitiesV2Error {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DetectEntitiesV2Error::InternalServer(ref cause) => write!(f, "{}", cause),
DetectEntitiesV2Error::InvalidEncoding(ref cause) => write!(f, "{}", cause),
DetectEntitiesV2Error::InvalidRequest(ref cause) => write!(f, "{}", cause),
DetectEntitiesV2Error::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
DetectEntitiesV2Error::TextSizeLimitExceeded(ref cause) => write!(f, "{}", cause),
DetectEntitiesV2Error::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DetectEntitiesV2Error {}
#[derive(Debug, PartialEq)]
pub enum DetectPHIError {
InternalServer(String),
InvalidEncoding(String),
InvalidRequest(String),
ServiceUnavailable(String),
TextSizeLimitExceeded(String),
TooManyRequests(String),
}
impl DetectPHIError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DetectPHIError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DetectPHIError::InternalServer(err.msg))
}
"InvalidEncodingException" => {
return RusotoError::Service(DetectPHIError::InvalidEncoding(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DetectPHIError::InvalidRequest(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DetectPHIError::ServiceUnavailable(err.msg))
}
"TextSizeLimitExceededException" => {
return RusotoError::Service(DetectPHIError::TextSizeLimitExceeded(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DetectPHIError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DetectPHIError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DetectPHIError::InternalServer(ref cause) => write!(f, "{}", cause),
DetectPHIError::InvalidEncoding(ref cause) => write!(f, "{}", cause),
DetectPHIError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DetectPHIError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
DetectPHIError::TextSizeLimitExceeded(ref cause) => write!(f, "{}", cause),
DetectPHIError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DetectPHIError {}
#[derive(Debug, PartialEq)]
pub enum InferICD10CMError {
InternalServer(String),
InvalidEncoding(String),
InvalidRequest(String),
ServiceUnavailable(String),
TextSizeLimitExceeded(String),
TooManyRequests(String),
}
impl InferICD10CMError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<InferICD10CMError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(InferICD10CMError::InternalServer(err.msg))
}
"InvalidEncodingException" => {
return RusotoError::Service(InferICD10CMError::InvalidEncoding(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(InferICD10CMError::InvalidRequest(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(InferICD10CMError::ServiceUnavailable(err.msg))
}
"TextSizeLimitExceededException" => {
return RusotoError::Service(InferICD10CMError::TextSizeLimitExceeded(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(InferICD10CMError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for InferICD10CMError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
InferICD10CMError::InternalServer(ref cause) => write!(f, "{}", cause),
InferICD10CMError::InvalidEncoding(ref cause) => write!(f, "{}", cause),
InferICD10CMError::InvalidRequest(ref cause) => write!(f, "{}", cause),
InferICD10CMError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
InferICD10CMError::TextSizeLimitExceeded(ref cause) => write!(f, "{}", cause),
InferICD10CMError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for InferICD10CMError {}
#[derive(Debug, PartialEq)]
pub enum InferRxNormError {
InternalServer(String),
InvalidEncoding(String),
InvalidRequest(String),
ServiceUnavailable(String),
TextSizeLimitExceeded(String),
TooManyRequests(String),
}
impl InferRxNormError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<InferRxNormError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(InferRxNormError::InternalServer(err.msg))
}
"InvalidEncodingException" => {
return RusotoError::Service(InferRxNormError::InvalidEncoding(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(InferRxNormError::InvalidRequest(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(InferRxNormError::ServiceUnavailable(err.msg))
}
"TextSizeLimitExceededException" => {
return RusotoError::Service(InferRxNormError::TextSizeLimitExceeded(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(InferRxNormError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for InferRxNormError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
InferRxNormError::InternalServer(ref cause) => write!(f, "{}", cause),
InferRxNormError::InvalidEncoding(ref cause) => write!(f, "{}", cause),
InferRxNormError::InvalidRequest(ref cause) => write!(f, "{}", cause),
InferRxNormError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
InferRxNormError::TextSizeLimitExceeded(ref cause) => write!(f, "{}", cause),
InferRxNormError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for InferRxNormError {}
#[derive(Debug, PartialEq)]
pub enum ListEntitiesDetectionV2JobsError {
InternalServer(String),
InvalidRequest(String),
TooManyRequests(String),
}
impl ListEntitiesDetectionV2JobsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListEntitiesDetectionV2JobsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListEntitiesDetectionV2JobsError::InternalServer(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(ListEntitiesDetectionV2JobsError::InvalidRequest(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListEntitiesDetectionV2JobsError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListEntitiesDetectionV2JobsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListEntitiesDetectionV2JobsError::InternalServer(ref cause) => write!(f, "{}", cause),
ListEntitiesDetectionV2JobsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListEntitiesDetectionV2JobsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListEntitiesDetectionV2JobsError {}
#[derive(Debug, PartialEq)]
pub enum ListICD10CMInferenceJobsError {
InternalServer(String),
InvalidRequest(String),
TooManyRequests(String),
}
impl ListICD10CMInferenceJobsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListICD10CMInferenceJobsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListICD10CMInferenceJobsError::InternalServer(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(ListICD10CMInferenceJobsError::InvalidRequest(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListICD10CMInferenceJobsError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListICD10CMInferenceJobsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListICD10CMInferenceJobsError::InternalServer(ref cause) => write!(f, "{}", cause),
ListICD10CMInferenceJobsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListICD10CMInferenceJobsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListICD10CMInferenceJobsError {}
#[derive(Debug, PartialEq)]
pub enum ListPHIDetectionJobsError {
InternalServer(String),
InvalidRequest(String),
TooManyRequests(String),
}
impl ListPHIDetectionJobsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListPHIDetectionJobsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListPHIDetectionJobsError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListPHIDetectionJobsError::InvalidRequest(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListPHIDetectionJobsError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListPHIDetectionJobsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListPHIDetectionJobsError::InternalServer(ref cause) => write!(f, "{}", cause),
ListPHIDetectionJobsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListPHIDetectionJobsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListPHIDetectionJobsError {}
#[derive(Debug, PartialEq)]
pub enum ListRxNormInferenceJobsError {
InternalServer(String),
InvalidRequest(String),
TooManyRequests(String),
}
impl ListRxNormInferenceJobsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListRxNormInferenceJobsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListRxNormInferenceJobsError::InternalServer(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(ListRxNormInferenceJobsError::InvalidRequest(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListRxNormInferenceJobsError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListRxNormInferenceJobsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListRxNormInferenceJobsError::InternalServer(ref cause) => write!(f, "{}", cause),
ListRxNormInferenceJobsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListRxNormInferenceJobsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListRxNormInferenceJobsError {}
#[derive(Debug, PartialEq)]
pub enum StartEntitiesDetectionV2JobError {
InternalServer(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl StartEntitiesDetectionV2JobError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<StartEntitiesDetectionV2JobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(StartEntitiesDetectionV2JobError::InternalServer(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(StartEntitiesDetectionV2JobError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(
StartEntitiesDetectionV2JobError::ResourceNotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(StartEntitiesDetectionV2JobError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartEntitiesDetectionV2JobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartEntitiesDetectionV2JobError::InternalServer(ref cause) => write!(f, "{}", cause),
StartEntitiesDetectionV2JobError::InvalidRequest(ref cause) => write!(f, "{}", cause),
StartEntitiesDetectionV2JobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
StartEntitiesDetectionV2JobError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartEntitiesDetectionV2JobError {}
#[derive(Debug, PartialEq)]
pub enum StartICD10CMInferenceJobError {
InternalServer(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl StartICD10CMInferenceJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartICD10CMInferenceJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(StartICD10CMInferenceJobError::InternalServer(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(StartICD10CMInferenceJobError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(StartICD10CMInferenceJobError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(StartICD10CMInferenceJobError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartICD10CMInferenceJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartICD10CMInferenceJobError::InternalServer(ref cause) => write!(f, "{}", cause),
StartICD10CMInferenceJobError::InvalidRequest(ref cause) => write!(f, "{}", cause),
StartICD10CMInferenceJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
StartICD10CMInferenceJobError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartICD10CMInferenceJobError {}
#[derive(Debug, PartialEq)]
pub enum StartPHIDetectionJobError {
InternalServer(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl StartPHIDetectionJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartPHIDetectionJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(StartPHIDetectionJobError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(StartPHIDetectionJobError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(StartPHIDetectionJobError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(StartPHIDetectionJobError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartPHIDetectionJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartPHIDetectionJobError::InternalServer(ref cause) => write!(f, "{}", cause),
StartPHIDetectionJobError::InvalidRequest(ref cause) => write!(f, "{}", cause),
StartPHIDetectionJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
StartPHIDetectionJobError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartPHIDetectionJobError {}
#[derive(Debug, PartialEq)]
pub enum StartRxNormInferenceJobError {
InternalServer(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl StartRxNormInferenceJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartRxNormInferenceJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(StartRxNormInferenceJobError::InternalServer(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(StartRxNormInferenceJobError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(StartRxNormInferenceJobError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(StartRxNormInferenceJobError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartRxNormInferenceJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartRxNormInferenceJobError::InternalServer(ref cause) => write!(f, "{}", cause),
StartRxNormInferenceJobError::InvalidRequest(ref cause) => write!(f, "{}", cause),
StartRxNormInferenceJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
StartRxNormInferenceJobError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartRxNormInferenceJobError {}
#[derive(Debug, PartialEq)]
pub enum StopEntitiesDetectionV2JobError {
InternalServer(String),
InvalidRequest(String),
ResourceNotFound(String),
}
impl StopEntitiesDetectionV2JobError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<StopEntitiesDetectionV2JobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(StopEntitiesDetectionV2JobError::InternalServer(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(StopEntitiesDetectionV2JobError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(StopEntitiesDetectionV2JobError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StopEntitiesDetectionV2JobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StopEntitiesDetectionV2JobError::InternalServer(ref cause) => write!(f, "{}", cause),
StopEntitiesDetectionV2JobError::InvalidRequest(ref cause) => write!(f, "{}", cause),
StopEntitiesDetectionV2JobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StopEntitiesDetectionV2JobError {}
#[derive(Debug, PartialEq)]
pub enum StopICD10CMInferenceJobError {
InternalServer(String),
InvalidRequest(String),
ResourceNotFound(String),
}
impl StopICD10CMInferenceJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopICD10CMInferenceJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(StopICD10CMInferenceJobError::InternalServer(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(StopICD10CMInferenceJobError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(StopICD10CMInferenceJobError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StopICD10CMInferenceJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StopICD10CMInferenceJobError::InternalServer(ref cause) => write!(f, "{}", cause),
StopICD10CMInferenceJobError::InvalidRequest(ref cause) => write!(f, "{}", cause),
StopICD10CMInferenceJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StopICD10CMInferenceJobError {}
#[derive(Debug, PartialEq)]
pub enum StopPHIDetectionJobError {
InternalServer(String),
InvalidRequest(String),
ResourceNotFound(String),
}
impl StopPHIDetectionJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopPHIDetectionJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(StopPHIDetectionJobError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(StopPHIDetectionJobError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(StopPHIDetectionJobError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StopPHIDetectionJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StopPHIDetectionJobError::InternalServer(ref cause) => write!(f, "{}", cause),
StopPHIDetectionJobError::InvalidRequest(ref cause) => write!(f, "{}", cause),
StopPHIDetectionJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StopPHIDetectionJobError {}
#[derive(Debug, PartialEq)]
pub enum StopRxNormInferenceJobError {
InternalServer(String),
InvalidRequest(String),
ResourceNotFound(String),
}
impl StopRxNormInferenceJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopRxNormInferenceJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(StopRxNormInferenceJobError::InternalServer(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(StopRxNormInferenceJobError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(StopRxNormInferenceJobError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StopRxNormInferenceJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StopRxNormInferenceJobError::InternalServer(ref cause) => write!(f, "{}", cause),
StopRxNormInferenceJobError::InvalidRequest(ref cause) => write!(f, "{}", cause),
StopRxNormInferenceJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StopRxNormInferenceJobError {}
#[async_trait]
pub trait ComprehendMedical {
async fn describe_entities_detection_v2_job(
&self,
input: DescribeEntitiesDetectionV2JobRequest,
) -> Result<
DescribeEntitiesDetectionV2JobResponse,
RusotoError<DescribeEntitiesDetectionV2JobError>,
>;
async fn describe_icd10cm_inference_job(
&self,
input: DescribeICD10CMInferenceJobRequest,
) -> Result<DescribeICD10CMInferenceJobResponse, RusotoError<DescribeICD10CMInferenceJobError>>;
async fn describe_phi_detection_job(
&self,
input: DescribePHIDetectionJobRequest,
) -> Result<DescribePHIDetectionJobResponse, RusotoError<DescribePHIDetectionJobError>>;
async fn describe_rx_norm_inference_job(
&self,
input: DescribeRxNormInferenceJobRequest,
) -> Result<DescribeRxNormInferenceJobResponse, RusotoError<DescribeRxNormInferenceJobError>>;
async fn detect_entities(
&self,
input: DetectEntitiesRequest,
) -> Result<DetectEntitiesResponse, RusotoError<DetectEntitiesError>>;
async fn detect_entities_v2(
&self,
input: DetectEntitiesV2Request,
) -> Result<DetectEntitiesV2Response, RusotoError<DetectEntitiesV2Error>>;
async fn detect_phi(
&self,
input: DetectPHIRequest,
) -> Result<DetectPHIResponse, RusotoError<DetectPHIError>>;
async fn infer_icd10cm(
&self,
input: InferICD10CMRequest,
) -> Result<InferICD10CMResponse, RusotoError<InferICD10CMError>>;
async fn infer_rx_norm(
&self,
input: InferRxNormRequest,
) -> Result<InferRxNormResponse, RusotoError<InferRxNormError>>;
async fn list_entities_detection_v2_jobs(
&self,
input: ListEntitiesDetectionV2JobsRequest,
) -> Result<ListEntitiesDetectionV2JobsResponse, RusotoError<ListEntitiesDetectionV2JobsError>>;
async fn list_icd10cm_inference_jobs(
&self,
input: ListICD10CMInferenceJobsRequest,
) -> Result<ListICD10CMInferenceJobsResponse, RusotoError<ListICD10CMInferenceJobsError>>;
async fn list_phi_detection_jobs(
&self,
input: ListPHIDetectionJobsRequest,
) -> Result<ListPHIDetectionJobsResponse, RusotoError<ListPHIDetectionJobsError>>;
async fn list_rx_norm_inference_jobs(
&self,
input: ListRxNormInferenceJobsRequest,
) -> Result<ListRxNormInferenceJobsResponse, RusotoError<ListRxNormInferenceJobsError>>;
async fn start_entities_detection_v2_job(
&self,
input: StartEntitiesDetectionV2JobRequest,
) -> Result<StartEntitiesDetectionV2JobResponse, RusotoError<StartEntitiesDetectionV2JobError>>;
async fn start_icd10cm_inference_job(
&self,
input: StartICD10CMInferenceJobRequest,
) -> Result<StartICD10CMInferenceJobResponse, RusotoError<StartICD10CMInferenceJobError>>;
async fn start_phi_detection_job(
&self,
input: StartPHIDetectionJobRequest,
) -> Result<StartPHIDetectionJobResponse, RusotoError<StartPHIDetectionJobError>>;
async fn start_rx_norm_inference_job(
&self,
input: StartRxNormInferenceJobRequest,
) -> Result<StartRxNormInferenceJobResponse, RusotoError<StartRxNormInferenceJobError>>;
async fn stop_entities_detection_v2_job(
&self,
input: StopEntitiesDetectionV2JobRequest,
) -> Result<StopEntitiesDetectionV2JobResponse, RusotoError<StopEntitiesDetectionV2JobError>>;
async fn stop_icd10cm_inference_job(
&self,
input: StopICD10CMInferenceJobRequest,
) -> Result<StopICD10CMInferenceJobResponse, RusotoError<StopICD10CMInferenceJobError>>;
async fn stop_phi_detection_job(
&self,
input: StopPHIDetectionJobRequest,
) -> Result<StopPHIDetectionJobResponse, RusotoError<StopPHIDetectionJobError>>;
async fn stop_rx_norm_inference_job(
&self,
input: StopRxNormInferenceJobRequest,
) -> Result<StopRxNormInferenceJobResponse, RusotoError<StopRxNormInferenceJobError>>;
}
#[derive(Clone)]
pub struct ComprehendMedicalClient {
client: Client,
region: region::Region,
}
impl ComprehendMedicalClient {
pub fn new(region: region::Region) -> ComprehendMedicalClient {
ComprehendMedicalClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> ComprehendMedicalClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
ComprehendMedicalClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> ComprehendMedicalClient {
ComprehendMedicalClient { client, region }
}
}
#[async_trait]
impl ComprehendMedical for ComprehendMedicalClient {
async fn describe_entities_detection_v2_job(
&self,
input: DescribeEntitiesDetectionV2JobRequest,
) -> Result<
DescribeEntitiesDetectionV2JobResponse,
RusotoError<DescribeEntitiesDetectionV2JobError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ComprehendMedical_20181030.DescribeEntitiesDetectionV2Job",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeEntitiesDetectionV2JobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeEntitiesDetectionV2JobResponse, _>()
}
async fn describe_icd10cm_inference_job(
&self,
input: DescribeICD10CMInferenceJobRequest,
) -> Result<DescribeICD10CMInferenceJobResponse, RusotoError<DescribeICD10CMInferenceJobError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ComprehendMedical_20181030.DescribeICD10CMInferenceJob",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeICD10CMInferenceJobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeICD10CMInferenceJobResponse, _>()
}
async fn describe_phi_detection_job(
&self,
input: DescribePHIDetectionJobRequest,
) -> Result<DescribePHIDetectionJobResponse, RusotoError<DescribePHIDetectionJobError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ComprehendMedical_20181030.DescribePHIDetectionJob",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribePHIDetectionJobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribePHIDetectionJobResponse, _>()
}
async fn describe_rx_norm_inference_job(
&self,
input: DescribeRxNormInferenceJobRequest,
) -> Result<DescribeRxNormInferenceJobResponse, RusotoError<DescribeRxNormInferenceJobError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ComprehendMedical_20181030.DescribeRxNormInferenceJob",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeRxNormInferenceJobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeRxNormInferenceJobResponse, _>()
}
async fn detect_entities(
&self,
input: DetectEntitiesRequest,
) -> Result<DetectEntitiesResponse, RusotoError<DetectEntitiesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "ComprehendMedical_20181030.DetectEntities");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DetectEntitiesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DetectEntitiesResponse, _>()
}
async fn detect_entities_v2(
&self,
input: DetectEntitiesV2Request,
) -> Result<DetectEntitiesV2Response, RusotoError<DetectEntitiesV2Error>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ComprehendMedical_20181030.DetectEntitiesV2",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DetectEntitiesV2Error::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DetectEntitiesV2Response, _>()
}
async fn detect_phi(
&self,
input: DetectPHIRequest,
) -> Result<DetectPHIResponse, RusotoError<DetectPHIError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "ComprehendMedical_20181030.DetectPHI");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DetectPHIError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DetectPHIResponse, _>()
}
async fn infer_icd10cm(
&self,
input: InferICD10CMRequest,
) -> Result<InferICD10CMResponse, RusotoError<InferICD10CMError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "ComprehendMedical_20181030.InferICD10CM");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, InferICD10CMError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<InferICD10CMResponse, _>()
}
async fn infer_rx_norm(
&self,
input: InferRxNormRequest,
) -> Result<InferRxNormResponse, RusotoError<InferRxNormError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "ComprehendMedical_20181030.InferRxNorm");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, InferRxNormError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<InferRxNormResponse, _>()
}
async fn list_entities_detection_v2_jobs(
&self,
input: ListEntitiesDetectionV2JobsRequest,
) -> Result<ListEntitiesDetectionV2JobsResponse, RusotoError<ListEntitiesDetectionV2JobsError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ComprehendMedical_20181030.ListEntitiesDetectionV2Jobs",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListEntitiesDetectionV2JobsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListEntitiesDetectionV2JobsResponse, _>()
}
async fn list_icd10cm_inference_jobs(
&self,
input: ListICD10CMInferenceJobsRequest,
) -> Result<ListICD10CMInferenceJobsResponse, RusotoError<ListICD10CMInferenceJobsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ComprehendMedical_20181030.ListICD10CMInferenceJobs",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListICD10CMInferenceJobsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListICD10CMInferenceJobsResponse, _>()
}
async fn list_phi_detection_jobs(
&self,
input: ListPHIDetectionJobsRequest,
) -> Result<ListPHIDetectionJobsResponse, RusotoError<ListPHIDetectionJobsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ComprehendMedical_20181030.ListPHIDetectionJobs",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListPHIDetectionJobsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListPHIDetectionJobsResponse, _>()
}
async fn list_rx_norm_inference_jobs(
&self,
input: ListRxNormInferenceJobsRequest,
) -> Result<ListRxNormInferenceJobsResponse, RusotoError<ListRxNormInferenceJobsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ComprehendMedical_20181030.ListRxNormInferenceJobs",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListRxNormInferenceJobsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListRxNormInferenceJobsResponse, _>()
}
async fn start_entities_detection_v2_job(
&self,
input: StartEntitiesDetectionV2JobRequest,
) -> Result<StartEntitiesDetectionV2JobResponse, RusotoError<StartEntitiesDetectionV2JobError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ComprehendMedical_20181030.StartEntitiesDetectionV2Job",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StartEntitiesDetectionV2JobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<StartEntitiesDetectionV2JobResponse, _>()
}
async fn start_icd10cm_inference_job(
&self,
input: StartICD10CMInferenceJobRequest,
) -> Result<StartICD10CMInferenceJobResponse, RusotoError<StartICD10CMInferenceJobError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ComprehendMedical_20181030.StartICD10CMInferenceJob",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StartICD10CMInferenceJobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<StartICD10CMInferenceJobResponse, _>()
}
async fn start_phi_detection_job(
&self,
input: StartPHIDetectionJobRequest,
) -> Result<StartPHIDetectionJobResponse, RusotoError<StartPHIDetectionJobError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ComprehendMedical_20181030.StartPHIDetectionJob",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StartPHIDetectionJobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<StartPHIDetectionJobResponse, _>()
}
async fn start_rx_norm_inference_job(
&self,
input: StartRxNormInferenceJobRequest,
) -> Result<StartRxNormInferenceJobResponse, RusotoError<StartRxNormInferenceJobError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ComprehendMedical_20181030.StartRxNormInferenceJob",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StartRxNormInferenceJobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<StartRxNormInferenceJobResponse, _>()
}
async fn stop_entities_detection_v2_job(
&self,
input: StopEntitiesDetectionV2JobRequest,
) -> Result<StopEntitiesDetectionV2JobResponse, RusotoError<StopEntitiesDetectionV2JobError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ComprehendMedical_20181030.StopEntitiesDetectionV2Job",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StopEntitiesDetectionV2JobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<StopEntitiesDetectionV2JobResponse, _>()
}
async fn stop_icd10cm_inference_job(
&self,
input: StopICD10CMInferenceJobRequest,
) -> Result<StopICD10CMInferenceJobResponse, RusotoError<StopICD10CMInferenceJobError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ComprehendMedical_20181030.StopICD10CMInferenceJob",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StopICD10CMInferenceJobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<StopICD10CMInferenceJobResponse, _>()
}
async fn stop_phi_detection_job(
&self,
input: StopPHIDetectionJobRequest,
) -> Result<StopPHIDetectionJobResponse, RusotoError<StopPHIDetectionJobError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ComprehendMedical_20181030.StopPHIDetectionJob",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StopPHIDetectionJobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<StopPHIDetectionJobResponse, _>()
}
async fn stop_rx_norm_inference_job(
&self,
input: StopRxNormInferenceJobRequest,
) -> Result<StopRxNormInferenceJobResponse, RusotoError<StopRxNormInferenceJobError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ComprehendMedical_20181030.StopRxNormInferenceJob",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StopRxNormInferenceJobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<StopRxNormInferenceJobResponse, _>()
}
}