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::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
use serde_json;
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[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 = "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<Trait>>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Default, Debug, Clone, 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(Default, Debug, Clone, PartialEq, Deserialize)]
#[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(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeEntitiesDetectionV2JobRequest {
#[serde(rename = "JobId")]
pub job_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[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(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribePHIDetectionJobRequest {
#[serde(rename = "JobId")]
pub job_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[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(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DetectEntitiesRequest {
#[serde(rename = "Text")]
pub text: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[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(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DetectEntitiesV2Request {
#[serde(rename = "Text")]
pub text: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[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(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DetectPHIRequest {
#[serde(rename = "Text")]
pub text: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[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(Default, Debug, Clone, PartialEq, Deserialize)]
#[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(Default, Debug, Clone, PartialEq, Deserialize)]
#[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(Default, Debug, Clone, PartialEq, Deserialize)]
#[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(Default, Debug, Clone, PartialEq, Deserialize)]
#[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(Default, Debug, Clone, PartialEq, Deserialize)]
#[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(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct InferICD10CMRequest {
#[serde(rename = "Text")]
pub text: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[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(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct InferRxNormRequest {
#[serde(rename = "Text")]
pub text: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[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(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
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(Default, Debug, Clone, 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(Default, Debug, Clone, PartialEq, Deserialize)]
#[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(Default, Debug, Clone, 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(Default, Debug, Clone, PartialEq, Deserialize)]
#[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(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
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(Default, Debug, Clone, PartialEq, Deserialize)]
#[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(Default, Debug, Clone, PartialEq, Deserialize)]
#[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(Default, Debug, Clone, PartialEq, Deserialize)]
#[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(Default, Debug, Clone, PartialEq, Deserialize)]
#[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(Default, Debug, Clone, 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(Default, Debug, Clone, PartialEq, Deserialize)]
#[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(Default, Debug, Clone, 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(Default, Debug, Clone, PartialEq, Deserialize)]
#[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(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopEntitiesDetectionV2JobRequest {
#[serde(rename = "JobId")]
pub job_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[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(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopPHIDetectionJobRequest {
#[serde(rename = "JobId")]
pub job_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[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(Default, Debug, Clone, PartialEq, Deserialize)]
#[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(Default, Debug, Clone, PartialEq, Deserialize)]
#[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 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 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 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 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 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 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 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 {}
#[async_trait]
pub trait ComprehendMedical {
async fn describe_entities_detection_v2_job(
&self,
input: DescribeEntitiesDetectionV2JobRequest,
) -> Result<
DescribeEntitiesDetectionV2JobResponse,
RusotoError<DescribeEntitiesDetectionV2JobError>,
>;
async fn describe_phi_detection_job(
&self,
input: DescribePHIDetectionJobRequest,
) -> Result<DescribePHIDetectionJobResponse, RusotoError<DescribePHIDetectionJobError>>;
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_phi_detection_jobs(
&self,
input: ListPHIDetectionJobsRequest,
) -> Result<ListPHIDetectionJobsResponse, RusotoError<ListPHIDetectionJobsError>>;
async fn start_entities_detection_v2_job(
&self,
input: StartEntitiesDetectionV2JobRequest,
) -> Result<StartEntitiesDetectionV2JobResponse, RusotoError<StartEntitiesDetectionV2JobError>>;
async fn start_phi_detection_job(
&self,
input: StartPHIDetectionJobRequest,
) -> Result<StartPHIDetectionJobResponse, RusotoError<StartPHIDetectionJobError>>;
async fn stop_entities_detection_v2_job(
&self,
input: StopEntitiesDetectionV2JobRequest,
) -> Result<StopEntitiesDetectionV2JobResponse, RusotoError<StopEntitiesDetectionV2JobError>>;
async fn stop_phi_detection_job(
&self,
input: StopPHIDetectionJobRequest,
) -> Result<StopPHIDetectionJobResponse, RusotoError<StopPHIDetectionJobError>>;
}
#[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 = SignedRequest::new("POST", "comprehendmedical", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"ComprehendMedical_20181030.DescribeEntitiesDetectionV2Job",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeEntitiesDetectionV2JobResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DescribeEntitiesDetectionV2JobError::from_response(response))
}
}
async fn describe_phi_detection_job(
&self,
input: DescribePHIDetectionJobRequest,
) -> Result<DescribePHIDetectionJobResponse, RusotoError<DescribePHIDetectionJobError>> {
let mut request = SignedRequest::new("POST", "comprehendmedical", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"ComprehendMedical_20181030.DescribePHIDetectionJob",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribePHIDetectionJobResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DescribePHIDetectionJobError::from_response(response))
}
}
async fn detect_entities(
&self,
input: DetectEntitiesRequest,
) -> Result<DetectEntitiesResponse, RusotoError<DetectEntitiesError>> {
let mut request = SignedRequest::new("POST", "comprehendmedical", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "ComprehendMedical_20181030.DetectEntities");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DetectEntitiesResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DetectEntitiesError::from_response(response))
}
}
async fn detect_entities_v2(
&self,
input: DetectEntitiesV2Request,
) -> Result<DetectEntitiesV2Response, RusotoError<DetectEntitiesV2Error>> {
let mut request = SignedRequest::new("POST", "comprehendmedical", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"ComprehendMedical_20181030.DetectEntitiesV2",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DetectEntitiesV2Response, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DetectEntitiesV2Error::from_response(response))
}
}
async fn detect_phi(
&self,
input: DetectPHIRequest,
) -> Result<DetectPHIResponse, RusotoError<DetectPHIError>> {
let mut request = SignedRequest::new("POST", "comprehendmedical", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "ComprehendMedical_20181030.DetectPHI");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DetectPHIResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DetectPHIError::from_response(response))
}
}
async fn infer_icd10cm(
&self,
input: InferICD10CMRequest,
) -> Result<InferICD10CMResponse, RusotoError<InferICD10CMError>> {
let mut request = SignedRequest::new("POST", "comprehendmedical", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "ComprehendMedical_20181030.InferICD10CM");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<InferICD10CMResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(InferICD10CMError::from_response(response))
}
}
async fn infer_rx_norm(
&self,
input: InferRxNormRequest,
) -> Result<InferRxNormResponse, RusotoError<InferRxNormError>> {
let mut request = SignedRequest::new("POST", "comprehendmedical", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "ComprehendMedical_20181030.InferRxNorm");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<InferRxNormResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(InferRxNormError::from_response(response))
}
}
async fn list_entities_detection_v2_jobs(
&self,
input: ListEntitiesDetectionV2JobsRequest,
) -> Result<ListEntitiesDetectionV2JobsResponse, RusotoError<ListEntitiesDetectionV2JobsError>>
{
let mut request = SignedRequest::new("POST", "comprehendmedical", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"ComprehendMedical_20181030.ListEntitiesDetectionV2Jobs",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListEntitiesDetectionV2JobsResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListEntitiesDetectionV2JobsError::from_response(response))
}
}
async fn list_phi_detection_jobs(
&self,
input: ListPHIDetectionJobsRequest,
) -> Result<ListPHIDetectionJobsResponse, RusotoError<ListPHIDetectionJobsError>> {
let mut request = SignedRequest::new("POST", "comprehendmedical", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"ComprehendMedical_20181030.ListPHIDetectionJobs",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListPHIDetectionJobsResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListPHIDetectionJobsError::from_response(response))
}
}
async fn start_entities_detection_v2_job(
&self,
input: StartEntitiesDetectionV2JobRequest,
) -> Result<StartEntitiesDetectionV2JobResponse, RusotoError<StartEntitiesDetectionV2JobError>>
{
let mut request = SignedRequest::new("POST", "comprehendmedical", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"ComprehendMedical_20181030.StartEntitiesDetectionV2Job",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<StartEntitiesDetectionV2JobResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(StartEntitiesDetectionV2JobError::from_response(response))
}
}
async fn start_phi_detection_job(
&self,
input: StartPHIDetectionJobRequest,
) -> Result<StartPHIDetectionJobResponse, RusotoError<StartPHIDetectionJobError>> {
let mut request = SignedRequest::new("POST", "comprehendmedical", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"ComprehendMedical_20181030.StartPHIDetectionJob",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<StartPHIDetectionJobResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(StartPHIDetectionJobError::from_response(response))
}
}
async fn stop_entities_detection_v2_job(
&self,
input: StopEntitiesDetectionV2JobRequest,
) -> Result<StopEntitiesDetectionV2JobResponse, RusotoError<StopEntitiesDetectionV2JobError>>
{
let mut request = SignedRequest::new("POST", "comprehendmedical", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"ComprehendMedical_20181030.StopEntitiesDetectionV2Job",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<StopEntitiesDetectionV2JobResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(StopEntitiesDetectionV2JobError::from_response(response))
}
}
async fn stop_phi_detection_job(
&self,
input: StopPHIDetectionJobRequest,
) -> Result<StopPHIDetectionJobResponse, RusotoError<StopPHIDetectionJobError>> {
let mut request = SignedRequest::new("POST", "comprehendmedical", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"ComprehendMedical_20181030.StopPHIDetectionJob",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<StopPHIDetectionJobResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(StopPHIDetectionJobError::from_response(response))
}
}
}