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 TranscribeClient {
fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
let mut request = SignedRequest::new(http_method, "transcribe", &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, Serialize)]
pub struct ContentRedaction {
#[serde(rename = "RedactionOutput")]
pub redaction_output: String,
#[serde(rename = "RedactionType")]
pub redaction_type: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateLanguageModelRequest {
#[serde(rename = "BaseModelName")]
pub base_model_name: String,
#[serde(rename = "InputDataConfig")]
pub input_data_config: InputDataConfig,
#[serde(rename = "LanguageCode")]
pub language_code: String,
#[serde(rename = "ModelName")]
pub model_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateLanguageModelResponse {
#[serde(rename = "BaseModelName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub base_model_name: Option<String>,
#[serde(rename = "InputDataConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_data_config: Option<InputDataConfig>,
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "ModelName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model_name: Option<String>,
#[serde(rename = "ModelStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model_status: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateMedicalVocabularyRequest {
#[serde(rename = "LanguageCode")]
pub language_code: String,
#[serde(rename = "VocabularyFileUri")]
pub vocabulary_file_uri: String,
#[serde(rename = "VocabularyName")]
pub vocabulary_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateMedicalVocabularyResponse {
#[serde(rename = "FailureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "LastModifiedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_time: Option<f64>,
#[serde(rename = "VocabularyName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabulary_name: Option<String>,
#[serde(rename = "VocabularyState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabulary_state: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateVocabularyFilterRequest {
#[serde(rename = "LanguageCode")]
pub language_code: String,
#[serde(rename = "VocabularyFilterFileUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabulary_filter_file_uri: Option<String>,
#[serde(rename = "VocabularyFilterName")]
pub vocabulary_filter_name: String,
#[serde(rename = "Words")]
#[serde(skip_serializing_if = "Option::is_none")]
pub words: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateVocabularyFilterResponse {
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "LastModifiedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_time: Option<f64>,
#[serde(rename = "VocabularyFilterName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabulary_filter_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateVocabularyRequest {
#[serde(rename = "LanguageCode")]
pub language_code: String,
#[serde(rename = "Phrases")]
#[serde(skip_serializing_if = "Option::is_none")]
pub phrases: Option<Vec<String>>,
#[serde(rename = "VocabularyFileUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabulary_file_uri: Option<String>,
#[serde(rename = "VocabularyName")]
pub vocabulary_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateVocabularyResponse {
#[serde(rename = "FailureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "LastModifiedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_time: Option<f64>,
#[serde(rename = "VocabularyName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabulary_name: Option<String>,
#[serde(rename = "VocabularyState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabulary_state: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteLanguageModelRequest {
#[serde(rename = "ModelName")]
pub model_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteMedicalTranscriptionJobRequest {
#[serde(rename = "MedicalTranscriptionJobName")]
pub medical_transcription_job_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteMedicalVocabularyRequest {
#[serde(rename = "VocabularyName")]
pub vocabulary_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteTranscriptionJobRequest {
#[serde(rename = "TranscriptionJobName")]
pub transcription_job_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteVocabularyFilterRequest {
#[serde(rename = "VocabularyFilterName")]
pub vocabulary_filter_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteVocabularyRequest {
#[serde(rename = "VocabularyName")]
pub vocabulary_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeLanguageModelRequest {
#[serde(rename = "ModelName")]
pub model_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeLanguageModelResponse {
#[serde(rename = "LanguageModel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_model: Option<LanguageModel>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetMedicalTranscriptionJobRequest {
#[serde(rename = "MedicalTranscriptionJobName")]
pub medical_transcription_job_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetMedicalTranscriptionJobResponse {
#[serde(rename = "MedicalTranscriptionJob")]
#[serde(skip_serializing_if = "Option::is_none")]
pub medical_transcription_job: Option<MedicalTranscriptionJob>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetMedicalVocabularyRequest {
#[serde(rename = "VocabularyName")]
pub vocabulary_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetMedicalVocabularyResponse {
#[serde(rename = "DownloadUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub download_uri: Option<String>,
#[serde(rename = "FailureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "LastModifiedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_time: Option<f64>,
#[serde(rename = "VocabularyName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabulary_name: Option<String>,
#[serde(rename = "VocabularyState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabulary_state: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetTranscriptionJobRequest {
#[serde(rename = "TranscriptionJobName")]
pub transcription_job_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetTranscriptionJobResponse {
#[serde(rename = "TranscriptionJob")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transcription_job: Option<TranscriptionJob>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetVocabularyFilterRequest {
#[serde(rename = "VocabularyFilterName")]
pub vocabulary_filter_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetVocabularyFilterResponse {
#[serde(rename = "DownloadUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub download_uri: Option<String>,
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "LastModifiedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_time: Option<f64>,
#[serde(rename = "VocabularyFilterName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabulary_filter_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetVocabularyRequest {
#[serde(rename = "VocabularyName")]
pub vocabulary_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetVocabularyResponse {
#[serde(rename = "DownloadUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub download_uri: Option<String>,
#[serde(rename = "FailureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "LastModifiedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_time: Option<f64>,
#[serde(rename = "VocabularyName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabulary_name: Option<String>,
#[serde(rename = "VocabularyState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabulary_state: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct InputDataConfig {
#[serde(rename = "DataAccessRoleArn")]
pub data_access_role_arn: String,
#[serde(rename = "S3Uri")]
pub s3_uri: String,
#[serde(rename = "TuningDataS3Uri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tuning_data_s3_uri: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct JobExecutionSettings {
#[serde(rename = "AllowDeferredExecution")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_deferred_execution: Option<bool>,
#[serde(rename = "DataAccessRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_access_role_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LanguageModel {
#[serde(rename = "BaseModelName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub base_model_name: Option<String>,
#[serde(rename = "CreateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub create_time: Option<f64>,
#[serde(rename = "FailureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "InputDataConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_data_config: Option<InputDataConfig>,
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "LastModifiedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_time: Option<f64>,
#[serde(rename = "ModelName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model_name: Option<String>,
#[serde(rename = "ModelStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model_status: Option<String>,
#[serde(rename = "UpgradeAvailability")]
#[serde(skip_serializing_if = "Option::is_none")]
pub upgrade_availability: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListLanguageModelsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NameContains")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name_contains: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "StatusEquals")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_equals: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListLanguageModelsResponse {
#[serde(rename = "Models")]
#[serde(skip_serializing_if = "Option::is_none")]
pub models: Option<Vec<LanguageModel>>,
#[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 ListMedicalTranscriptionJobsRequest {
#[serde(rename = "JobNameContains")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_name_contains: Option<String>,
#[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>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListMedicalTranscriptionJobsResponse {
#[serde(rename = "MedicalTranscriptionJobSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub medical_transcription_job_summaries: Option<Vec<MedicalTranscriptionJobSummary>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListMedicalVocabulariesRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NameContains")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name_contains: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "StateEquals")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state_equals: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListMedicalVocabulariesResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "Vocabularies")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabularies: Option<Vec<VocabularyInfo>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTranscriptionJobsRequest {
#[serde(rename = "JobNameContains")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_name_contains: Option<String>,
#[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>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTranscriptionJobsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "TranscriptionJobSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transcription_job_summaries: Option<Vec<TranscriptionJobSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListVocabulariesRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NameContains")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name_contains: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "StateEquals")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state_equals: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListVocabulariesResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "Vocabularies")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabularies: Option<Vec<VocabularyInfo>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListVocabularyFiltersRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NameContains")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name_contains: Option<String>,
#[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 ListVocabularyFiltersResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "VocabularyFilters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabulary_filters: Option<Vec<VocabularyFilterInfo>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Media {
#[serde(rename = "MediaFileUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub media_file_uri: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MedicalTranscript {
#[serde(rename = "TranscriptFileUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transcript_file_uri: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MedicalTranscriptionJob {
#[serde(rename = "CompletionTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub completion_time: Option<f64>,
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "FailureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "Media")]
#[serde(skip_serializing_if = "Option::is_none")]
pub media: Option<Media>,
#[serde(rename = "MediaFormat")]
#[serde(skip_serializing_if = "Option::is_none")]
pub media_format: Option<String>,
#[serde(rename = "MediaSampleRateHertz")]
#[serde(skip_serializing_if = "Option::is_none")]
pub media_sample_rate_hertz: Option<i64>,
#[serde(rename = "MedicalTranscriptionJobName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub medical_transcription_job_name: Option<String>,
#[serde(rename = "Settings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub settings: Option<MedicalTranscriptionSetting>,
#[serde(rename = "Specialty")]
#[serde(skip_serializing_if = "Option::is_none")]
pub specialty: Option<String>,
#[serde(rename = "StartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
#[serde(rename = "Transcript")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transcript: Option<MedicalTranscript>,
#[serde(rename = "TranscriptionJobStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transcription_job_status: Option<String>,
#[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 MedicalTranscriptionJobSummary {
#[serde(rename = "CompletionTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub completion_time: Option<f64>,
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "FailureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "MedicalTranscriptionJobName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub medical_transcription_job_name: Option<String>,
#[serde(rename = "OutputLocationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_location_type: Option<String>,
#[serde(rename = "Specialty")]
#[serde(skip_serializing_if = "Option::is_none")]
pub specialty: Option<String>,
#[serde(rename = "StartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
#[serde(rename = "TranscriptionJobStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transcription_job_status: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MedicalTranscriptionSetting {
#[serde(rename = "ChannelIdentification")]
#[serde(skip_serializing_if = "Option::is_none")]
pub channel_identification: Option<bool>,
#[serde(rename = "MaxAlternatives")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_alternatives: Option<i64>,
#[serde(rename = "MaxSpeakerLabels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_speaker_labels: Option<i64>,
#[serde(rename = "ShowAlternatives")]
#[serde(skip_serializing_if = "Option::is_none")]
pub show_alternatives: Option<bool>,
#[serde(rename = "ShowSpeakerLabels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub show_speaker_labels: Option<bool>,
#[serde(rename = "VocabularyName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabulary_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ModelSettings {
#[serde(rename = "LanguageModelName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_model_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Settings {
#[serde(rename = "ChannelIdentification")]
#[serde(skip_serializing_if = "Option::is_none")]
pub channel_identification: Option<bool>,
#[serde(rename = "MaxAlternatives")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_alternatives: Option<i64>,
#[serde(rename = "MaxSpeakerLabels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_speaker_labels: Option<i64>,
#[serde(rename = "ShowAlternatives")]
#[serde(skip_serializing_if = "Option::is_none")]
pub show_alternatives: Option<bool>,
#[serde(rename = "ShowSpeakerLabels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub show_speaker_labels: Option<bool>,
#[serde(rename = "VocabularyFilterMethod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabulary_filter_method: Option<String>,
#[serde(rename = "VocabularyFilterName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabulary_filter_name: Option<String>,
#[serde(rename = "VocabularyName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabulary_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartMedicalTranscriptionJobRequest {
#[serde(rename = "LanguageCode")]
pub language_code: String,
#[serde(rename = "Media")]
pub media: Media,
#[serde(rename = "MediaFormat")]
#[serde(skip_serializing_if = "Option::is_none")]
pub media_format: Option<String>,
#[serde(rename = "MediaSampleRateHertz")]
#[serde(skip_serializing_if = "Option::is_none")]
pub media_sample_rate_hertz: Option<i64>,
#[serde(rename = "MedicalTranscriptionJobName")]
pub medical_transcription_job_name: String,
#[serde(rename = "OutputBucketName")]
pub output_bucket_name: String,
#[serde(rename = "OutputEncryptionKMSKeyId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_encryption_kms_key_id: Option<String>,
#[serde(rename = "OutputKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_key: Option<String>,
#[serde(rename = "Settings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub settings: Option<MedicalTranscriptionSetting>,
#[serde(rename = "Specialty")]
pub specialty: String,
#[serde(rename = "Type")]
pub type_: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartMedicalTranscriptionJobResponse {
#[serde(rename = "MedicalTranscriptionJob")]
#[serde(skip_serializing_if = "Option::is_none")]
pub medical_transcription_job: Option<MedicalTranscriptionJob>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartTranscriptionJobRequest {
#[serde(rename = "ContentRedaction")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_redaction: Option<ContentRedaction>,
#[serde(rename = "IdentifyLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identify_language: Option<bool>,
#[serde(rename = "JobExecutionSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_execution_settings: Option<JobExecutionSettings>,
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "LanguageOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_options: Option<Vec<String>>,
#[serde(rename = "Media")]
pub media: Media,
#[serde(rename = "MediaFormat")]
#[serde(skip_serializing_if = "Option::is_none")]
pub media_format: Option<String>,
#[serde(rename = "MediaSampleRateHertz")]
#[serde(skip_serializing_if = "Option::is_none")]
pub media_sample_rate_hertz: Option<i64>,
#[serde(rename = "ModelSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model_settings: Option<ModelSettings>,
#[serde(rename = "OutputBucketName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_bucket_name: Option<String>,
#[serde(rename = "OutputEncryptionKMSKeyId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_encryption_kms_key_id: Option<String>,
#[serde(rename = "OutputKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_key: Option<String>,
#[serde(rename = "Settings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub settings: Option<Settings>,
#[serde(rename = "TranscriptionJobName")]
pub transcription_job_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartTranscriptionJobResponse {
#[serde(rename = "TranscriptionJob")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transcription_job: Option<TranscriptionJob>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Transcript {
#[serde(rename = "RedactedTranscriptFileUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub redacted_transcript_file_uri: Option<String>,
#[serde(rename = "TranscriptFileUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transcript_file_uri: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TranscriptionJob {
#[serde(rename = "CompletionTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub completion_time: Option<f64>,
#[serde(rename = "ContentRedaction")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_redaction: Option<ContentRedaction>,
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "FailureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "IdentifiedLanguageScore")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identified_language_score: Option<f32>,
#[serde(rename = "IdentifyLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identify_language: Option<bool>,
#[serde(rename = "JobExecutionSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_execution_settings: Option<JobExecutionSettings>,
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "LanguageOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_options: Option<Vec<String>>,
#[serde(rename = "Media")]
#[serde(skip_serializing_if = "Option::is_none")]
pub media: Option<Media>,
#[serde(rename = "MediaFormat")]
#[serde(skip_serializing_if = "Option::is_none")]
pub media_format: Option<String>,
#[serde(rename = "MediaSampleRateHertz")]
#[serde(skip_serializing_if = "Option::is_none")]
pub media_sample_rate_hertz: Option<i64>,
#[serde(rename = "ModelSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model_settings: Option<ModelSettings>,
#[serde(rename = "Settings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub settings: Option<Settings>,
#[serde(rename = "StartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
#[serde(rename = "Transcript")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transcript: Option<Transcript>,
#[serde(rename = "TranscriptionJobName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transcription_job_name: Option<String>,
#[serde(rename = "TranscriptionJobStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transcription_job_status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TranscriptionJobSummary {
#[serde(rename = "CompletionTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub completion_time: Option<f64>,
#[serde(rename = "ContentRedaction")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_redaction: Option<ContentRedaction>,
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "FailureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "IdentifiedLanguageScore")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identified_language_score: Option<f32>,
#[serde(rename = "IdentifyLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identify_language: Option<bool>,
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "ModelSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model_settings: Option<ModelSettings>,
#[serde(rename = "OutputLocationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_location_type: Option<String>,
#[serde(rename = "StartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
#[serde(rename = "TranscriptionJobName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transcription_job_name: Option<String>,
#[serde(rename = "TranscriptionJobStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transcription_job_status: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateMedicalVocabularyRequest {
#[serde(rename = "LanguageCode")]
pub language_code: String,
#[serde(rename = "VocabularyFileUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabulary_file_uri: Option<String>,
#[serde(rename = "VocabularyName")]
pub vocabulary_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateMedicalVocabularyResponse {
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "LastModifiedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_time: Option<f64>,
#[serde(rename = "VocabularyName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabulary_name: Option<String>,
#[serde(rename = "VocabularyState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabulary_state: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateVocabularyFilterRequest {
#[serde(rename = "VocabularyFilterFileUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabulary_filter_file_uri: Option<String>,
#[serde(rename = "VocabularyFilterName")]
pub vocabulary_filter_name: String,
#[serde(rename = "Words")]
#[serde(skip_serializing_if = "Option::is_none")]
pub words: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateVocabularyFilterResponse {
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "LastModifiedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_time: Option<f64>,
#[serde(rename = "VocabularyFilterName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabulary_filter_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateVocabularyRequest {
#[serde(rename = "LanguageCode")]
pub language_code: String,
#[serde(rename = "Phrases")]
#[serde(skip_serializing_if = "Option::is_none")]
pub phrases: Option<Vec<String>>,
#[serde(rename = "VocabularyFileUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabulary_file_uri: Option<String>,
#[serde(rename = "VocabularyName")]
pub vocabulary_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateVocabularyResponse {
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "LastModifiedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_time: Option<f64>,
#[serde(rename = "VocabularyName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabulary_name: Option<String>,
#[serde(rename = "VocabularyState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabulary_state: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct VocabularyFilterInfo {
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "LastModifiedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_time: Option<f64>,
#[serde(rename = "VocabularyFilterName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabulary_filter_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct VocabularyInfo {
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "LastModifiedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_time: Option<f64>,
#[serde(rename = "VocabularyName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabulary_name: Option<String>,
#[serde(rename = "VocabularyState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vocabulary_state: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum CreateLanguageModelError {
BadRequest(String),
Conflict(String),
InternalFailure(String),
LimitExceeded(String),
}
impl CreateLanguageModelError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateLanguageModelError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateLanguageModelError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(CreateLanguageModelError::Conflict(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(CreateLanguageModelError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateLanguageModelError::LimitExceeded(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateLanguageModelError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateLanguageModelError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateLanguageModelError::Conflict(ref cause) => write!(f, "{}", cause),
CreateLanguageModelError::InternalFailure(ref cause) => write!(f, "{}", cause),
CreateLanguageModelError::LimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateLanguageModelError {}
#[derive(Debug, PartialEq)]
pub enum CreateMedicalVocabularyError {
BadRequest(String),
Conflict(String),
InternalFailure(String),
LimitExceeded(String),
}
impl CreateMedicalVocabularyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateMedicalVocabularyError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateMedicalVocabularyError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(CreateMedicalVocabularyError::Conflict(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(CreateMedicalVocabularyError::InternalFailure(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(CreateMedicalVocabularyError::LimitExceeded(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateMedicalVocabularyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateMedicalVocabularyError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateMedicalVocabularyError::Conflict(ref cause) => write!(f, "{}", cause),
CreateMedicalVocabularyError::InternalFailure(ref cause) => write!(f, "{}", cause),
CreateMedicalVocabularyError::LimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateMedicalVocabularyError {}
#[derive(Debug, PartialEq)]
pub enum CreateVocabularyError {
BadRequest(String),
Conflict(String),
InternalFailure(String),
LimitExceeded(String),
}
impl CreateVocabularyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateVocabularyError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateVocabularyError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(CreateVocabularyError::Conflict(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(CreateVocabularyError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateVocabularyError::LimitExceeded(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateVocabularyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateVocabularyError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateVocabularyError::Conflict(ref cause) => write!(f, "{}", cause),
CreateVocabularyError::InternalFailure(ref cause) => write!(f, "{}", cause),
CreateVocabularyError::LimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateVocabularyError {}
#[derive(Debug, PartialEq)]
pub enum CreateVocabularyFilterError {
BadRequest(String),
Conflict(String),
InternalFailure(String),
LimitExceeded(String),
}
impl CreateVocabularyFilterError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateVocabularyFilterError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateVocabularyFilterError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(CreateVocabularyFilterError::Conflict(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(CreateVocabularyFilterError::InternalFailure(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(CreateVocabularyFilterError::LimitExceeded(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateVocabularyFilterError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateVocabularyFilterError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateVocabularyFilterError::Conflict(ref cause) => write!(f, "{}", cause),
CreateVocabularyFilterError::InternalFailure(ref cause) => write!(f, "{}", cause),
CreateVocabularyFilterError::LimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateVocabularyFilterError {}
#[derive(Debug, PartialEq)]
pub enum DeleteLanguageModelError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
}
impl DeleteLanguageModelError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteLanguageModelError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteLanguageModelError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(DeleteLanguageModelError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(DeleteLanguageModelError::LimitExceeded(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteLanguageModelError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteLanguageModelError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteLanguageModelError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeleteLanguageModelError::LimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteLanguageModelError {}
#[derive(Debug, PartialEq)]
pub enum DeleteMedicalTranscriptionJobError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
}
impl DeleteMedicalTranscriptionJobError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteMedicalTranscriptionJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteMedicalTranscriptionJobError::BadRequest(
err.msg,
))
}
"InternalFailureException" => {
return RusotoError::Service(
DeleteMedicalTranscriptionJobError::InternalFailure(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(DeleteMedicalTranscriptionJobError::LimitExceeded(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteMedicalTranscriptionJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteMedicalTranscriptionJobError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteMedicalTranscriptionJobError::InternalFailure(ref cause) => {
write!(f, "{}", cause)
}
DeleteMedicalTranscriptionJobError::LimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteMedicalTranscriptionJobError {}
#[derive(Debug, PartialEq)]
pub enum DeleteMedicalVocabularyError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
}
impl DeleteMedicalVocabularyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteMedicalVocabularyError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteMedicalVocabularyError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(DeleteMedicalVocabularyError::InternalFailure(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(DeleteMedicalVocabularyError::LimitExceeded(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(DeleteMedicalVocabularyError::NotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteMedicalVocabularyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteMedicalVocabularyError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteMedicalVocabularyError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeleteMedicalVocabularyError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteMedicalVocabularyError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteMedicalVocabularyError {}
#[derive(Debug, PartialEq)]
pub enum DeleteTranscriptionJobError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
}
impl DeleteTranscriptionJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteTranscriptionJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteTranscriptionJobError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(DeleteTranscriptionJobError::InternalFailure(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(DeleteTranscriptionJobError::LimitExceeded(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteTranscriptionJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteTranscriptionJobError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteTranscriptionJobError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeleteTranscriptionJobError::LimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteTranscriptionJobError {}
#[derive(Debug, PartialEq)]
pub enum DeleteVocabularyError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
}
impl DeleteVocabularyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteVocabularyError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteVocabularyError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(DeleteVocabularyError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(DeleteVocabularyError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteVocabularyError::NotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteVocabularyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteVocabularyError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteVocabularyError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeleteVocabularyError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteVocabularyError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteVocabularyError {}
#[derive(Debug, PartialEq)]
pub enum DeleteVocabularyFilterError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
}
impl DeleteVocabularyFilterError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteVocabularyFilterError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteVocabularyFilterError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(DeleteVocabularyFilterError::InternalFailure(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(DeleteVocabularyFilterError::LimitExceeded(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(DeleteVocabularyFilterError::NotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteVocabularyFilterError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteVocabularyFilterError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteVocabularyFilterError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeleteVocabularyFilterError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteVocabularyFilterError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteVocabularyFilterError {}
#[derive(Debug, PartialEq)]
pub enum DescribeLanguageModelError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
}
impl DescribeLanguageModelError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeLanguageModelError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DescribeLanguageModelError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(DescribeLanguageModelError::InternalFailure(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(DescribeLanguageModelError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DescribeLanguageModelError::NotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeLanguageModelError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeLanguageModelError::BadRequest(ref cause) => write!(f, "{}", cause),
DescribeLanguageModelError::InternalFailure(ref cause) => write!(f, "{}", cause),
DescribeLanguageModelError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DescribeLanguageModelError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeLanguageModelError {}
#[derive(Debug, PartialEq)]
pub enum GetMedicalTranscriptionJobError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
}
impl GetMedicalTranscriptionJobError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetMedicalTranscriptionJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetMedicalTranscriptionJobError::BadRequest(
err.msg,
))
}
"InternalFailureException" => {
return RusotoError::Service(GetMedicalTranscriptionJobError::InternalFailure(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(GetMedicalTranscriptionJobError::LimitExceeded(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(GetMedicalTranscriptionJobError::NotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetMedicalTranscriptionJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetMedicalTranscriptionJobError::BadRequest(ref cause) => write!(f, "{}", cause),
GetMedicalTranscriptionJobError::InternalFailure(ref cause) => write!(f, "{}", cause),
GetMedicalTranscriptionJobError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetMedicalTranscriptionJobError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetMedicalTranscriptionJobError {}
#[derive(Debug, PartialEq)]
pub enum GetMedicalVocabularyError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
}
impl GetMedicalVocabularyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetMedicalVocabularyError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetMedicalVocabularyError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(GetMedicalVocabularyError::InternalFailure(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(GetMedicalVocabularyError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetMedicalVocabularyError::NotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetMedicalVocabularyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetMedicalVocabularyError::BadRequest(ref cause) => write!(f, "{}", cause),
GetMedicalVocabularyError::InternalFailure(ref cause) => write!(f, "{}", cause),
GetMedicalVocabularyError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetMedicalVocabularyError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetMedicalVocabularyError {}
#[derive(Debug, PartialEq)]
pub enum GetTranscriptionJobError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
}
impl GetTranscriptionJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetTranscriptionJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetTranscriptionJobError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(GetTranscriptionJobError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(GetTranscriptionJobError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetTranscriptionJobError::NotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetTranscriptionJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetTranscriptionJobError::BadRequest(ref cause) => write!(f, "{}", cause),
GetTranscriptionJobError::InternalFailure(ref cause) => write!(f, "{}", cause),
GetTranscriptionJobError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetTranscriptionJobError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetTranscriptionJobError {}
#[derive(Debug, PartialEq)]
pub enum GetVocabularyError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
}
impl GetVocabularyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetVocabularyError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetVocabularyError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(GetVocabularyError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(GetVocabularyError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetVocabularyError::NotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetVocabularyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetVocabularyError::BadRequest(ref cause) => write!(f, "{}", cause),
GetVocabularyError::InternalFailure(ref cause) => write!(f, "{}", cause),
GetVocabularyError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetVocabularyError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetVocabularyError {}
#[derive(Debug, PartialEq)]
pub enum GetVocabularyFilterError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
}
impl GetVocabularyFilterError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetVocabularyFilterError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetVocabularyFilterError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(GetVocabularyFilterError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(GetVocabularyFilterError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetVocabularyFilterError::NotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetVocabularyFilterError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetVocabularyFilterError::BadRequest(ref cause) => write!(f, "{}", cause),
GetVocabularyFilterError::InternalFailure(ref cause) => write!(f, "{}", cause),
GetVocabularyFilterError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetVocabularyFilterError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetVocabularyFilterError {}
#[derive(Debug, PartialEq)]
pub enum ListLanguageModelsError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
}
impl ListLanguageModelsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListLanguageModelsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListLanguageModelsError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(ListLanguageModelsError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListLanguageModelsError::LimitExceeded(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListLanguageModelsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListLanguageModelsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListLanguageModelsError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListLanguageModelsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListLanguageModelsError {}
#[derive(Debug, PartialEq)]
pub enum ListMedicalTranscriptionJobsError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
}
impl ListMedicalTranscriptionJobsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListMedicalTranscriptionJobsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListMedicalTranscriptionJobsError::BadRequest(
err.msg,
))
}
"InternalFailureException" => {
return RusotoError::Service(
ListMedicalTranscriptionJobsError::InternalFailure(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(ListMedicalTranscriptionJobsError::LimitExceeded(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListMedicalTranscriptionJobsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListMedicalTranscriptionJobsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListMedicalTranscriptionJobsError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListMedicalTranscriptionJobsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListMedicalTranscriptionJobsError {}
#[derive(Debug, PartialEq)]
pub enum ListMedicalVocabulariesError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
}
impl ListMedicalVocabulariesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListMedicalVocabulariesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListMedicalVocabulariesError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(ListMedicalVocabulariesError::InternalFailure(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(ListMedicalVocabulariesError::LimitExceeded(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListMedicalVocabulariesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListMedicalVocabulariesError::BadRequest(ref cause) => write!(f, "{}", cause),
ListMedicalVocabulariesError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListMedicalVocabulariesError::LimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListMedicalVocabulariesError {}
#[derive(Debug, PartialEq)]
pub enum ListTranscriptionJobsError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
}
impl ListTranscriptionJobsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTranscriptionJobsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListTranscriptionJobsError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(ListTranscriptionJobsError::InternalFailure(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(ListTranscriptionJobsError::LimitExceeded(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTranscriptionJobsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTranscriptionJobsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListTranscriptionJobsError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListTranscriptionJobsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTranscriptionJobsError {}
#[derive(Debug, PartialEq)]
pub enum ListVocabulariesError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
}
impl ListVocabulariesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListVocabulariesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListVocabulariesError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(ListVocabulariesError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListVocabulariesError::LimitExceeded(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListVocabulariesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListVocabulariesError::BadRequest(ref cause) => write!(f, "{}", cause),
ListVocabulariesError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListVocabulariesError::LimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListVocabulariesError {}
#[derive(Debug, PartialEq)]
pub enum ListVocabularyFiltersError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
}
impl ListVocabularyFiltersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListVocabularyFiltersError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListVocabularyFiltersError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(ListVocabularyFiltersError::InternalFailure(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(ListVocabularyFiltersError::LimitExceeded(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListVocabularyFiltersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListVocabularyFiltersError::BadRequest(ref cause) => write!(f, "{}", cause),
ListVocabularyFiltersError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListVocabularyFiltersError::LimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListVocabularyFiltersError {}
#[derive(Debug, PartialEq)]
pub enum StartMedicalTranscriptionJobError {
BadRequest(String),
Conflict(String),
InternalFailure(String),
LimitExceeded(String),
}
impl StartMedicalTranscriptionJobError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<StartMedicalTranscriptionJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(StartMedicalTranscriptionJobError::BadRequest(
err.msg,
))
}
"ConflictException" => {
return RusotoError::Service(StartMedicalTranscriptionJobError::Conflict(
err.msg,
))
}
"InternalFailureException" => {
return RusotoError::Service(
StartMedicalTranscriptionJobError::InternalFailure(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(StartMedicalTranscriptionJobError::LimitExceeded(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartMedicalTranscriptionJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartMedicalTranscriptionJobError::BadRequest(ref cause) => write!(f, "{}", cause),
StartMedicalTranscriptionJobError::Conflict(ref cause) => write!(f, "{}", cause),
StartMedicalTranscriptionJobError::InternalFailure(ref cause) => write!(f, "{}", cause),
StartMedicalTranscriptionJobError::LimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartMedicalTranscriptionJobError {}
#[derive(Debug, PartialEq)]
pub enum StartTranscriptionJobError {
BadRequest(String),
Conflict(String),
InternalFailure(String),
LimitExceeded(String),
}
impl StartTranscriptionJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartTranscriptionJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(StartTranscriptionJobError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(StartTranscriptionJobError::Conflict(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(StartTranscriptionJobError::InternalFailure(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(StartTranscriptionJobError::LimitExceeded(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartTranscriptionJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartTranscriptionJobError::BadRequest(ref cause) => write!(f, "{}", cause),
StartTranscriptionJobError::Conflict(ref cause) => write!(f, "{}", cause),
StartTranscriptionJobError::InternalFailure(ref cause) => write!(f, "{}", cause),
StartTranscriptionJobError::LimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartTranscriptionJobError {}
#[derive(Debug, PartialEq)]
pub enum UpdateMedicalVocabularyError {
BadRequest(String),
Conflict(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
}
impl UpdateMedicalVocabularyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateMedicalVocabularyError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateMedicalVocabularyError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(UpdateMedicalVocabularyError::Conflict(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(UpdateMedicalVocabularyError::InternalFailure(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(UpdateMedicalVocabularyError::LimitExceeded(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(UpdateMedicalVocabularyError::NotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateMedicalVocabularyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateMedicalVocabularyError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateMedicalVocabularyError::Conflict(ref cause) => write!(f, "{}", cause),
UpdateMedicalVocabularyError::InternalFailure(ref cause) => write!(f, "{}", cause),
UpdateMedicalVocabularyError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateMedicalVocabularyError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateMedicalVocabularyError {}
#[derive(Debug, PartialEq)]
pub enum UpdateVocabularyError {
BadRequest(String),
Conflict(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
}
impl UpdateVocabularyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateVocabularyError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateVocabularyError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(UpdateVocabularyError::Conflict(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(UpdateVocabularyError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(UpdateVocabularyError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateVocabularyError::NotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateVocabularyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateVocabularyError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateVocabularyError::Conflict(ref cause) => write!(f, "{}", cause),
UpdateVocabularyError::InternalFailure(ref cause) => write!(f, "{}", cause),
UpdateVocabularyError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateVocabularyError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateVocabularyError {}
#[derive(Debug, PartialEq)]
pub enum UpdateVocabularyFilterError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
}
impl UpdateVocabularyFilterError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateVocabularyFilterError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateVocabularyFilterError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(UpdateVocabularyFilterError::InternalFailure(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(UpdateVocabularyFilterError::LimitExceeded(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(UpdateVocabularyFilterError::NotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateVocabularyFilterError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateVocabularyFilterError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateVocabularyFilterError::InternalFailure(ref cause) => write!(f, "{}", cause),
UpdateVocabularyFilterError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateVocabularyFilterError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateVocabularyFilterError {}
#[async_trait]
pub trait Transcribe {
async fn create_language_model(
&self,
input: CreateLanguageModelRequest,
) -> Result<CreateLanguageModelResponse, RusotoError<CreateLanguageModelError>>;
async fn create_medical_vocabulary(
&self,
input: CreateMedicalVocabularyRequest,
) -> Result<CreateMedicalVocabularyResponse, RusotoError<CreateMedicalVocabularyError>>;
async fn create_vocabulary(
&self,
input: CreateVocabularyRequest,
) -> Result<CreateVocabularyResponse, RusotoError<CreateVocabularyError>>;
async fn create_vocabulary_filter(
&self,
input: CreateVocabularyFilterRequest,
) -> Result<CreateVocabularyFilterResponse, RusotoError<CreateVocabularyFilterError>>;
async fn delete_language_model(
&self,
input: DeleteLanguageModelRequest,
) -> Result<(), RusotoError<DeleteLanguageModelError>>;
async fn delete_medical_transcription_job(
&self,
input: DeleteMedicalTranscriptionJobRequest,
) -> Result<(), RusotoError<DeleteMedicalTranscriptionJobError>>;
async fn delete_medical_vocabulary(
&self,
input: DeleteMedicalVocabularyRequest,
) -> Result<(), RusotoError<DeleteMedicalVocabularyError>>;
async fn delete_transcription_job(
&self,
input: DeleteTranscriptionJobRequest,
) -> Result<(), RusotoError<DeleteTranscriptionJobError>>;
async fn delete_vocabulary(
&self,
input: DeleteVocabularyRequest,
) -> Result<(), RusotoError<DeleteVocabularyError>>;
async fn delete_vocabulary_filter(
&self,
input: DeleteVocabularyFilterRequest,
) -> Result<(), RusotoError<DeleteVocabularyFilterError>>;
async fn describe_language_model(
&self,
input: DescribeLanguageModelRequest,
) -> Result<DescribeLanguageModelResponse, RusotoError<DescribeLanguageModelError>>;
async fn get_medical_transcription_job(
&self,
input: GetMedicalTranscriptionJobRequest,
) -> Result<GetMedicalTranscriptionJobResponse, RusotoError<GetMedicalTranscriptionJobError>>;
async fn get_medical_vocabulary(
&self,
input: GetMedicalVocabularyRequest,
) -> Result<GetMedicalVocabularyResponse, RusotoError<GetMedicalVocabularyError>>;
async fn get_transcription_job(
&self,
input: GetTranscriptionJobRequest,
) -> Result<GetTranscriptionJobResponse, RusotoError<GetTranscriptionJobError>>;
async fn get_vocabulary(
&self,
input: GetVocabularyRequest,
) -> Result<GetVocabularyResponse, RusotoError<GetVocabularyError>>;
async fn get_vocabulary_filter(
&self,
input: GetVocabularyFilterRequest,
) -> Result<GetVocabularyFilterResponse, RusotoError<GetVocabularyFilterError>>;
async fn list_language_models(
&self,
input: ListLanguageModelsRequest,
) -> Result<ListLanguageModelsResponse, RusotoError<ListLanguageModelsError>>;
async fn list_medical_transcription_jobs(
&self,
input: ListMedicalTranscriptionJobsRequest,
) -> Result<ListMedicalTranscriptionJobsResponse, RusotoError<ListMedicalTranscriptionJobsError>>;
async fn list_medical_vocabularies(
&self,
input: ListMedicalVocabulariesRequest,
) -> Result<ListMedicalVocabulariesResponse, RusotoError<ListMedicalVocabulariesError>>;
async fn list_transcription_jobs(
&self,
input: ListTranscriptionJobsRequest,
) -> Result<ListTranscriptionJobsResponse, RusotoError<ListTranscriptionJobsError>>;
async fn list_vocabularies(
&self,
input: ListVocabulariesRequest,
) -> Result<ListVocabulariesResponse, RusotoError<ListVocabulariesError>>;
async fn list_vocabulary_filters(
&self,
input: ListVocabularyFiltersRequest,
) -> Result<ListVocabularyFiltersResponse, RusotoError<ListVocabularyFiltersError>>;
async fn start_medical_transcription_job(
&self,
input: StartMedicalTranscriptionJobRequest,
) -> Result<StartMedicalTranscriptionJobResponse, RusotoError<StartMedicalTranscriptionJobError>>;
async fn start_transcription_job(
&self,
input: StartTranscriptionJobRequest,
) -> Result<StartTranscriptionJobResponse, RusotoError<StartTranscriptionJobError>>;
async fn update_medical_vocabulary(
&self,
input: UpdateMedicalVocabularyRequest,
) -> Result<UpdateMedicalVocabularyResponse, RusotoError<UpdateMedicalVocabularyError>>;
async fn update_vocabulary(
&self,
input: UpdateVocabularyRequest,
) -> Result<UpdateVocabularyResponse, RusotoError<UpdateVocabularyError>>;
async fn update_vocabulary_filter(
&self,
input: UpdateVocabularyFilterRequest,
) -> Result<UpdateVocabularyFilterResponse, RusotoError<UpdateVocabularyFilterError>>;
}
#[derive(Clone)]
pub struct TranscribeClient {
client: Client,
region: region::Region,
}
impl TranscribeClient {
pub fn new(region: region::Region) -> TranscribeClient {
TranscribeClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> TranscribeClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
TranscribeClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> TranscribeClient {
TranscribeClient { client, region }
}
}
#[async_trait]
impl Transcribe for TranscribeClient {
async fn create_language_model(
&self,
input: CreateLanguageModelRequest,
) -> Result<CreateLanguageModelResponse, RusotoError<CreateLanguageModelError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Transcribe.CreateLanguageModel");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateLanguageModelError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateLanguageModelResponse, _>()
}
async fn create_medical_vocabulary(
&self,
input: CreateMedicalVocabularyRequest,
) -> Result<CreateMedicalVocabularyResponse, RusotoError<CreateMedicalVocabularyError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Transcribe.CreateMedicalVocabulary");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateMedicalVocabularyError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateMedicalVocabularyResponse, _>()
}
async fn create_vocabulary(
&self,
input: CreateVocabularyRequest,
) -> Result<CreateVocabularyResponse, RusotoError<CreateVocabularyError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Transcribe.CreateVocabulary");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateVocabularyError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateVocabularyResponse, _>()
}
async fn create_vocabulary_filter(
&self,
input: CreateVocabularyFilterRequest,
) -> Result<CreateVocabularyFilterResponse, RusotoError<CreateVocabularyFilterError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Transcribe.CreateVocabularyFilter");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateVocabularyFilterError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateVocabularyFilterResponse, _>()
}
async fn delete_language_model(
&self,
input: DeleteLanguageModelRequest,
) -> Result<(), RusotoError<DeleteLanguageModelError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Transcribe.DeleteLanguageModel");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteLanguageModelError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_medical_transcription_job(
&self,
input: DeleteMedicalTranscriptionJobRequest,
) -> Result<(), RusotoError<DeleteMedicalTranscriptionJobError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Transcribe.DeleteMedicalTranscriptionJob");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteMedicalTranscriptionJobError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_medical_vocabulary(
&self,
input: DeleteMedicalVocabularyRequest,
) -> Result<(), RusotoError<DeleteMedicalVocabularyError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Transcribe.DeleteMedicalVocabulary");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteMedicalVocabularyError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_transcription_job(
&self,
input: DeleteTranscriptionJobRequest,
) -> Result<(), RusotoError<DeleteTranscriptionJobError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Transcribe.DeleteTranscriptionJob");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteTranscriptionJobError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_vocabulary(
&self,
input: DeleteVocabularyRequest,
) -> Result<(), RusotoError<DeleteVocabularyError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Transcribe.DeleteVocabulary");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteVocabularyError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_vocabulary_filter(
&self,
input: DeleteVocabularyFilterRequest,
) -> Result<(), RusotoError<DeleteVocabularyFilterError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Transcribe.DeleteVocabularyFilter");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteVocabularyFilterError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn describe_language_model(
&self,
input: DescribeLanguageModelRequest,
) -> Result<DescribeLanguageModelResponse, RusotoError<DescribeLanguageModelError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Transcribe.DescribeLanguageModel");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeLanguageModelError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeLanguageModelResponse, _>()
}
async fn get_medical_transcription_job(
&self,
input: GetMedicalTranscriptionJobRequest,
) -> Result<GetMedicalTranscriptionJobResponse, RusotoError<GetMedicalTranscriptionJobError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Transcribe.GetMedicalTranscriptionJob");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetMedicalTranscriptionJobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetMedicalTranscriptionJobResponse, _>()
}
async fn get_medical_vocabulary(
&self,
input: GetMedicalVocabularyRequest,
) -> Result<GetMedicalVocabularyResponse, RusotoError<GetMedicalVocabularyError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Transcribe.GetMedicalVocabulary");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetMedicalVocabularyError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetMedicalVocabularyResponse, _>()
}
async fn get_transcription_job(
&self,
input: GetTranscriptionJobRequest,
) -> Result<GetTranscriptionJobResponse, RusotoError<GetTranscriptionJobError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Transcribe.GetTranscriptionJob");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetTranscriptionJobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetTranscriptionJobResponse, _>()
}
async fn get_vocabulary(
&self,
input: GetVocabularyRequest,
) -> Result<GetVocabularyResponse, RusotoError<GetVocabularyError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Transcribe.GetVocabulary");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetVocabularyError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetVocabularyResponse, _>()
}
async fn get_vocabulary_filter(
&self,
input: GetVocabularyFilterRequest,
) -> Result<GetVocabularyFilterResponse, RusotoError<GetVocabularyFilterError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Transcribe.GetVocabularyFilter");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetVocabularyFilterError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetVocabularyFilterResponse, _>()
}
async fn list_language_models(
&self,
input: ListLanguageModelsRequest,
) -> Result<ListLanguageModelsResponse, RusotoError<ListLanguageModelsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Transcribe.ListLanguageModels");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListLanguageModelsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListLanguageModelsResponse, _>()
}
async fn list_medical_transcription_jobs(
&self,
input: ListMedicalTranscriptionJobsRequest,
) -> Result<ListMedicalTranscriptionJobsResponse, RusotoError<ListMedicalTranscriptionJobsError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Transcribe.ListMedicalTranscriptionJobs");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListMedicalTranscriptionJobsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListMedicalTranscriptionJobsResponse, _>()
}
async fn list_medical_vocabularies(
&self,
input: ListMedicalVocabulariesRequest,
) -> Result<ListMedicalVocabulariesResponse, RusotoError<ListMedicalVocabulariesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Transcribe.ListMedicalVocabularies");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListMedicalVocabulariesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListMedicalVocabulariesResponse, _>()
}
async fn list_transcription_jobs(
&self,
input: ListTranscriptionJobsRequest,
) -> Result<ListTranscriptionJobsResponse, RusotoError<ListTranscriptionJobsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Transcribe.ListTranscriptionJobs");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListTranscriptionJobsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListTranscriptionJobsResponse, _>()
}
async fn list_vocabularies(
&self,
input: ListVocabulariesRequest,
) -> Result<ListVocabulariesResponse, RusotoError<ListVocabulariesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Transcribe.ListVocabularies");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListVocabulariesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListVocabulariesResponse, _>()
}
async fn list_vocabulary_filters(
&self,
input: ListVocabularyFiltersRequest,
) -> Result<ListVocabularyFiltersResponse, RusotoError<ListVocabularyFiltersError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Transcribe.ListVocabularyFilters");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListVocabularyFiltersError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListVocabularyFiltersResponse, _>()
}
async fn start_medical_transcription_job(
&self,
input: StartMedicalTranscriptionJobRequest,
) -> Result<StartMedicalTranscriptionJobResponse, RusotoError<StartMedicalTranscriptionJobError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Transcribe.StartMedicalTranscriptionJob");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StartMedicalTranscriptionJobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<StartMedicalTranscriptionJobResponse, _>()
}
async fn start_transcription_job(
&self,
input: StartTranscriptionJobRequest,
) -> Result<StartTranscriptionJobResponse, RusotoError<StartTranscriptionJobError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Transcribe.StartTranscriptionJob");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StartTranscriptionJobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<StartTranscriptionJobResponse, _>()
}
async fn update_medical_vocabulary(
&self,
input: UpdateMedicalVocabularyRequest,
) -> Result<UpdateMedicalVocabularyResponse, RusotoError<UpdateMedicalVocabularyError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Transcribe.UpdateMedicalVocabulary");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateMedicalVocabularyError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateMedicalVocabularyResponse, _>()
}
async fn update_vocabulary(
&self,
input: UpdateVocabularyRequest,
) -> Result<UpdateVocabularyResponse, RusotoError<UpdateVocabularyError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Transcribe.UpdateVocabulary");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateVocabularyError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateVocabularyResponse, _>()
}
async fn update_vocabulary_filter(
&self,
input: UpdateVocabularyFilterRequest,
) -> Result<UpdateVocabularyFilterResponse, RusotoError<UpdateVocabularyFilterError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Transcribe.UpdateVocabularyFilter");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateVocabularyFilterError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateVocabularyFilterResponse, _>()
}
}