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::param::{Params, ServiceParams};
use rusoto_core::proto;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
use serde_json;
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteLexiconInput {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteLexiconOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeVoicesInput {
#[serde(rename = "Engine")]
#[serde(skip_serializing_if = "Option::is_none")]
pub engine: Option<String>,
#[serde(rename = "IncludeAdditionalLanguageCodes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub include_additional_language_codes: Option<bool>,
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: 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 DescribeVoicesOutput {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Voices")]
#[serde(skip_serializing_if = "Option::is_none")]
pub voices: Option<Vec<Voice>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetLexiconInput {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetLexiconOutput {
#[serde(rename = "Lexicon")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lexicon: Option<Lexicon>,
#[serde(rename = "LexiconAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lexicon_attributes: Option<LexiconAttributes>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetSpeechSynthesisTaskInput {
#[serde(rename = "TaskId")]
pub task_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetSpeechSynthesisTaskOutput {
#[serde(rename = "SynthesisTask")]
#[serde(skip_serializing_if = "Option::is_none")]
pub synthesis_task: Option<SynthesisTask>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Lexicon {
#[serde(rename = "Content")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LexiconAttributes {
#[serde(rename = "Alphabet")]
#[serde(skip_serializing_if = "Option::is_none")]
pub alphabet: Option<String>,
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "LastModified")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified: Option<f64>,
#[serde(rename = "LexemesCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lexemes_count: Option<i64>,
#[serde(rename = "LexiconArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lexicon_arn: Option<String>,
#[serde(rename = "Size")]
#[serde(skip_serializing_if = "Option::is_none")]
pub size: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LexiconDescription {
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<LexiconAttributes>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListLexiconsInput {
#[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 ListLexiconsOutput {
#[serde(rename = "Lexicons")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lexicons: Option<Vec<LexiconDescription>>,
#[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 ListSpeechSynthesisTasksInput {
#[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 ListSpeechSynthesisTasksOutput {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "SynthesisTasks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub synthesis_tasks: Option<Vec<SynthesisTask>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutLexiconInput {
#[serde(rename = "Content")]
pub content: String,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutLexiconOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartSpeechSynthesisTaskInput {
#[serde(rename = "Engine")]
#[serde(skip_serializing_if = "Option::is_none")]
pub engine: Option<String>,
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "LexiconNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lexicon_names: Option<Vec<String>>,
#[serde(rename = "OutputFormat")]
pub output_format: String,
#[serde(rename = "OutputS3BucketName")]
pub output_s3_bucket_name: String,
#[serde(rename = "OutputS3KeyPrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_s3_key_prefix: Option<String>,
#[serde(rename = "SampleRate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sample_rate: Option<String>,
#[serde(rename = "SnsTopicArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sns_topic_arn: Option<String>,
#[serde(rename = "SpeechMarkTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub speech_mark_types: Option<Vec<String>>,
#[serde(rename = "Text")]
pub text: String,
#[serde(rename = "TextType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub text_type: Option<String>,
#[serde(rename = "VoiceId")]
pub voice_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartSpeechSynthesisTaskOutput {
#[serde(rename = "SynthesisTask")]
#[serde(skip_serializing_if = "Option::is_none")]
pub synthesis_task: Option<SynthesisTask>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SynthesisTask {
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "Engine")]
#[serde(skip_serializing_if = "Option::is_none")]
pub engine: Option<String>,
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "LexiconNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lexicon_names: Option<Vec<String>>,
#[serde(rename = "OutputFormat")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_format: Option<String>,
#[serde(rename = "OutputUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_uri: Option<String>,
#[serde(rename = "RequestCharacters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_characters: Option<i64>,
#[serde(rename = "SampleRate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sample_rate: Option<String>,
#[serde(rename = "SnsTopicArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sns_topic_arn: Option<String>,
#[serde(rename = "SpeechMarkTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub speech_mark_types: Option<Vec<String>>,
#[serde(rename = "TaskId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub task_id: Option<String>,
#[serde(rename = "TaskStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub task_status: Option<String>,
#[serde(rename = "TaskStatusReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub task_status_reason: Option<String>,
#[serde(rename = "TextType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub text_type: Option<String>,
#[serde(rename = "VoiceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub voice_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SynthesizeSpeechInput {
#[serde(rename = "Engine")]
#[serde(skip_serializing_if = "Option::is_none")]
pub engine: Option<String>,
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "LexiconNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lexicon_names: Option<Vec<String>>,
#[serde(rename = "OutputFormat")]
pub output_format: String,
#[serde(rename = "SampleRate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sample_rate: Option<String>,
#[serde(rename = "SpeechMarkTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub speech_mark_types: Option<Vec<String>>,
#[serde(rename = "Text")]
pub text: String,
#[serde(rename = "TextType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub text_type: Option<String>,
#[serde(rename = "VoiceId")]
pub voice_id: String,
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct SynthesizeSpeechOutput {
pub audio_stream: Option<bytes::Bytes>,
pub content_type: Option<String>,
pub request_characters: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Voice {
#[serde(rename = "AdditionalLanguageCodes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub additional_language_codes: Option<Vec<String>>,
#[serde(rename = "Gender")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gender: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "LanguageName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_name: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "SupportedEngines")]
#[serde(skip_serializing_if = "Option::is_none")]
pub supported_engines: Option<Vec<String>>,
}
#[derive(Debug, PartialEq)]
pub enum DeleteLexiconError {
LexiconNotFound(String),
ServiceFailure(String),
}
impl DeleteLexiconError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteLexiconError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"LexiconNotFoundException" => {
return RusotoError::Service(DeleteLexiconError::LexiconNotFound(err.msg))
}
"ServiceFailureException" => {
return RusotoError::Service(DeleteLexiconError::ServiceFailure(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteLexiconError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteLexiconError::LexiconNotFound(ref cause) => write!(f, "{}", cause),
DeleteLexiconError::ServiceFailure(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteLexiconError {}
#[derive(Debug, PartialEq)]
pub enum DescribeVoicesError {
InvalidNextToken(String),
ServiceFailure(String),
}
impl DescribeVoicesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeVoicesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(DescribeVoicesError::InvalidNextToken(err.msg))
}
"ServiceFailureException" => {
return RusotoError::Service(DescribeVoicesError::ServiceFailure(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeVoicesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeVoicesError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
DescribeVoicesError::ServiceFailure(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeVoicesError {}
#[derive(Debug, PartialEq)]
pub enum GetLexiconError {
LexiconNotFound(String),
ServiceFailure(String),
}
impl GetLexiconError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetLexiconError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"LexiconNotFoundException" => {
return RusotoError::Service(GetLexiconError::LexiconNotFound(err.msg))
}
"ServiceFailureException" => {
return RusotoError::Service(GetLexiconError::ServiceFailure(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetLexiconError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetLexiconError::LexiconNotFound(ref cause) => write!(f, "{}", cause),
GetLexiconError::ServiceFailure(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetLexiconError {}
#[derive(Debug, PartialEq)]
pub enum GetSpeechSynthesisTaskError {
InvalidTaskId(String),
ServiceFailure(String),
SynthesisTaskNotFound(String),
}
impl GetSpeechSynthesisTaskError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetSpeechSynthesisTaskError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidTaskIdException" => {
return RusotoError::Service(GetSpeechSynthesisTaskError::InvalidTaskId(
err.msg,
))
}
"ServiceFailureException" => {
return RusotoError::Service(GetSpeechSynthesisTaskError::ServiceFailure(
err.msg,
))
}
"SynthesisTaskNotFoundException" => {
return RusotoError::Service(
GetSpeechSynthesisTaskError::SynthesisTaskNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetSpeechSynthesisTaskError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetSpeechSynthesisTaskError::InvalidTaskId(ref cause) => write!(f, "{}", cause),
GetSpeechSynthesisTaskError::ServiceFailure(ref cause) => write!(f, "{}", cause),
GetSpeechSynthesisTaskError::SynthesisTaskNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetSpeechSynthesisTaskError {}
#[derive(Debug, PartialEq)]
pub enum ListLexiconsError {
InvalidNextToken(String),
ServiceFailure(String),
}
impl ListLexiconsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListLexiconsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(ListLexiconsError::InvalidNextToken(err.msg))
}
"ServiceFailureException" => {
return RusotoError::Service(ListLexiconsError::ServiceFailure(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListLexiconsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListLexiconsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListLexiconsError::ServiceFailure(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListLexiconsError {}
#[derive(Debug, PartialEq)]
pub enum ListSpeechSynthesisTasksError {
InvalidNextToken(String),
ServiceFailure(String),
}
impl ListSpeechSynthesisTasksError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListSpeechSynthesisTasksError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(ListSpeechSynthesisTasksError::InvalidNextToken(
err.msg,
))
}
"ServiceFailureException" => {
return RusotoError::Service(ListSpeechSynthesisTasksError::ServiceFailure(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListSpeechSynthesisTasksError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListSpeechSynthesisTasksError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListSpeechSynthesisTasksError::ServiceFailure(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListSpeechSynthesisTasksError {}
#[derive(Debug, PartialEq)]
pub enum PutLexiconError {
InvalidLexicon(String),
LexiconSizeExceeded(String),
MaxLexemeLengthExceeded(String),
MaxLexiconsNumberExceeded(String),
ServiceFailure(String),
UnsupportedPlsAlphabet(String),
UnsupportedPlsLanguage(String),
}
impl PutLexiconError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutLexiconError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidLexiconException" => {
return RusotoError::Service(PutLexiconError::InvalidLexicon(err.msg))
}
"LexiconSizeExceededException" => {
return RusotoError::Service(PutLexiconError::LexiconSizeExceeded(err.msg))
}
"MaxLexemeLengthExceededException" => {
return RusotoError::Service(PutLexiconError::MaxLexemeLengthExceeded(err.msg))
}
"MaxLexiconsNumberExceededException" => {
return RusotoError::Service(PutLexiconError::MaxLexiconsNumberExceeded(
err.msg,
))
}
"ServiceFailureException" => {
return RusotoError::Service(PutLexiconError::ServiceFailure(err.msg))
}
"UnsupportedPlsAlphabetException" => {
return RusotoError::Service(PutLexiconError::UnsupportedPlsAlphabet(err.msg))
}
"UnsupportedPlsLanguageException" => {
return RusotoError::Service(PutLexiconError::UnsupportedPlsLanguage(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutLexiconError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutLexiconError::InvalidLexicon(ref cause) => write!(f, "{}", cause),
PutLexiconError::LexiconSizeExceeded(ref cause) => write!(f, "{}", cause),
PutLexiconError::MaxLexemeLengthExceeded(ref cause) => write!(f, "{}", cause),
PutLexiconError::MaxLexiconsNumberExceeded(ref cause) => write!(f, "{}", cause),
PutLexiconError::ServiceFailure(ref cause) => write!(f, "{}", cause),
PutLexiconError::UnsupportedPlsAlphabet(ref cause) => write!(f, "{}", cause),
PutLexiconError::UnsupportedPlsLanguage(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutLexiconError {}
#[derive(Debug, PartialEq)]
pub enum StartSpeechSynthesisTaskError {
EngineNotSupported(String),
InvalidS3Bucket(String),
InvalidS3Key(String),
InvalidSampleRate(String),
InvalidSnsTopicArn(String),
InvalidSsml(String),
LanguageNotSupported(String),
LexiconNotFound(String),
MarksNotSupportedForFormat(String),
ServiceFailure(String),
SsmlMarksNotSupportedForTextType(String),
TextLengthExceeded(String),
}
impl StartSpeechSynthesisTaskError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartSpeechSynthesisTaskError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"EngineNotSupportedException" => {
return RusotoError::Service(StartSpeechSynthesisTaskError::EngineNotSupported(
err.msg,
))
}
"InvalidS3BucketException" => {
return RusotoError::Service(StartSpeechSynthesisTaskError::InvalidS3Bucket(
err.msg,
))
}
"InvalidS3KeyException" => {
return RusotoError::Service(StartSpeechSynthesisTaskError::InvalidS3Key(
err.msg,
))
}
"InvalidSampleRateException" => {
return RusotoError::Service(StartSpeechSynthesisTaskError::InvalidSampleRate(
err.msg,
))
}
"InvalidSnsTopicArnException" => {
return RusotoError::Service(StartSpeechSynthesisTaskError::InvalidSnsTopicArn(
err.msg,
))
}
"InvalidSsmlException" => {
return RusotoError::Service(StartSpeechSynthesisTaskError::InvalidSsml(
err.msg,
))
}
"LanguageNotSupportedException" => {
return RusotoError::Service(
StartSpeechSynthesisTaskError::LanguageNotSupported(err.msg),
)
}
"LexiconNotFoundException" => {
return RusotoError::Service(StartSpeechSynthesisTaskError::LexiconNotFound(
err.msg,
))
}
"MarksNotSupportedForFormatException" => {
return RusotoError::Service(
StartSpeechSynthesisTaskError::MarksNotSupportedForFormat(err.msg),
)
}
"ServiceFailureException" => {
return RusotoError::Service(StartSpeechSynthesisTaskError::ServiceFailure(
err.msg,
))
}
"SsmlMarksNotSupportedForTextTypeException" => {
return RusotoError::Service(
StartSpeechSynthesisTaskError::SsmlMarksNotSupportedForTextType(err.msg),
)
}
"TextLengthExceededException" => {
return RusotoError::Service(StartSpeechSynthesisTaskError::TextLengthExceeded(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartSpeechSynthesisTaskError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartSpeechSynthesisTaskError::EngineNotSupported(ref cause) => write!(f, "{}", cause),
StartSpeechSynthesisTaskError::InvalidS3Bucket(ref cause) => write!(f, "{}", cause),
StartSpeechSynthesisTaskError::InvalidS3Key(ref cause) => write!(f, "{}", cause),
StartSpeechSynthesisTaskError::InvalidSampleRate(ref cause) => write!(f, "{}", cause),
StartSpeechSynthesisTaskError::InvalidSnsTopicArn(ref cause) => write!(f, "{}", cause),
StartSpeechSynthesisTaskError::InvalidSsml(ref cause) => write!(f, "{}", cause),
StartSpeechSynthesisTaskError::LanguageNotSupported(ref cause) => {
write!(f, "{}", cause)
}
StartSpeechSynthesisTaskError::LexiconNotFound(ref cause) => write!(f, "{}", cause),
StartSpeechSynthesisTaskError::MarksNotSupportedForFormat(ref cause) => {
write!(f, "{}", cause)
}
StartSpeechSynthesisTaskError::ServiceFailure(ref cause) => write!(f, "{}", cause),
StartSpeechSynthesisTaskError::SsmlMarksNotSupportedForTextType(ref cause) => {
write!(f, "{}", cause)
}
StartSpeechSynthesisTaskError::TextLengthExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartSpeechSynthesisTaskError {}
#[derive(Debug, PartialEq)]
pub enum SynthesizeSpeechError {
EngineNotSupported(String),
InvalidSampleRate(String),
InvalidSsml(String),
LanguageNotSupported(String),
LexiconNotFound(String),
MarksNotSupportedForFormat(String),
ServiceFailure(String),
SsmlMarksNotSupportedForTextType(String),
TextLengthExceeded(String),
}
impl SynthesizeSpeechError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SynthesizeSpeechError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"EngineNotSupportedException" => {
return RusotoError::Service(SynthesizeSpeechError::EngineNotSupported(err.msg))
}
"InvalidSampleRateException" => {
return RusotoError::Service(SynthesizeSpeechError::InvalidSampleRate(err.msg))
}
"InvalidSsmlException" => {
return RusotoError::Service(SynthesizeSpeechError::InvalidSsml(err.msg))
}
"LanguageNotSupportedException" => {
return RusotoError::Service(SynthesizeSpeechError::LanguageNotSupported(
err.msg,
))
}
"LexiconNotFoundException" => {
return RusotoError::Service(SynthesizeSpeechError::LexiconNotFound(err.msg))
}
"MarksNotSupportedForFormatException" => {
return RusotoError::Service(SynthesizeSpeechError::MarksNotSupportedForFormat(
err.msg,
))
}
"ServiceFailureException" => {
return RusotoError::Service(SynthesizeSpeechError::ServiceFailure(err.msg))
}
"SsmlMarksNotSupportedForTextTypeException" => {
return RusotoError::Service(
SynthesizeSpeechError::SsmlMarksNotSupportedForTextType(err.msg),
)
}
"TextLengthExceededException" => {
return RusotoError::Service(SynthesizeSpeechError::TextLengthExceeded(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SynthesizeSpeechError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SynthesizeSpeechError::EngineNotSupported(ref cause) => write!(f, "{}", cause),
SynthesizeSpeechError::InvalidSampleRate(ref cause) => write!(f, "{}", cause),
SynthesizeSpeechError::InvalidSsml(ref cause) => write!(f, "{}", cause),
SynthesizeSpeechError::LanguageNotSupported(ref cause) => write!(f, "{}", cause),
SynthesizeSpeechError::LexiconNotFound(ref cause) => write!(f, "{}", cause),
SynthesizeSpeechError::MarksNotSupportedForFormat(ref cause) => write!(f, "{}", cause),
SynthesizeSpeechError::ServiceFailure(ref cause) => write!(f, "{}", cause),
SynthesizeSpeechError::SsmlMarksNotSupportedForTextType(ref cause) => {
write!(f, "{}", cause)
}
SynthesizeSpeechError::TextLengthExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SynthesizeSpeechError {}
#[async_trait]
pub trait Polly {
async fn delete_lexicon(
&self,
input: DeleteLexiconInput,
) -> Result<DeleteLexiconOutput, RusotoError<DeleteLexiconError>>;
async fn describe_voices(
&self,
input: DescribeVoicesInput,
) -> Result<DescribeVoicesOutput, RusotoError<DescribeVoicesError>>;
async fn get_lexicon(
&self,
input: GetLexiconInput,
) -> Result<GetLexiconOutput, RusotoError<GetLexiconError>>;
async fn get_speech_synthesis_task(
&self,
input: GetSpeechSynthesisTaskInput,
) -> Result<GetSpeechSynthesisTaskOutput, RusotoError<GetSpeechSynthesisTaskError>>;
async fn list_lexicons(
&self,
input: ListLexiconsInput,
) -> Result<ListLexiconsOutput, RusotoError<ListLexiconsError>>;
async fn list_speech_synthesis_tasks(
&self,
input: ListSpeechSynthesisTasksInput,
) -> Result<ListSpeechSynthesisTasksOutput, RusotoError<ListSpeechSynthesisTasksError>>;
async fn put_lexicon(
&self,
input: PutLexiconInput,
) -> Result<PutLexiconOutput, RusotoError<PutLexiconError>>;
async fn start_speech_synthesis_task(
&self,
input: StartSpeechSynthesisTaskInput,
) -> Result<StartSpeechSynthesisTaskOutput, RusotoError<StartSpeechSynthesisTaskError>>;
async fn synthesize_speech(
&self,
input: SynthesizeSpeechInput,
) -> Result<SynthesizeSpeechOutput, RusotoError<SynthesizeSpeechError>>;
}
#[derive(Clone)]
pub struct PollyClient {
client: Client,
region: region::Region,
}
impl PollyClient {
pub fn new(region: region::Region) -> PollyClient {
PollyClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> PollyClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
PollyClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> PollyClient {
PollyClient { client, region }
}
}
#[async_trait]
impl Polly for PollyClient {
#[allow(unused_mut)]
async fn delete_lexicon(
&self,
input: DeleteLexiconInput,
) -> Result<DeleteLexiconOutput, RusotoError<DeleteLexiconError>> {
let request_uri = format!("/v1/lexicons/{lexicon_name}", lexicon_name = input.name);
let mut request = SignedRequest::new("DELETE", "polly", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteLexiconOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteLexiconError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_voices(
&self,
input: DescribeVoicesInput,
) -> Result<DescribeVoicesOutput, RusotoError<DescribeVoicesError>> {
let request_uri = "/v1/voices";
let mut request = SignedRequest::new("GET", "polly", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.engine {
params.put("Engine", x);
}
if let Some(ref x) = input.include_additional_language_codes {
params.put("IncludeAdditionalLanguageCodes", x);
}
if let Some(ref x) = input.language_code {
params.put("LanguageCode", x);
}
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeVoicesOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeVoicesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_lexicon(
&self,
input: GetLexiconInput,
) -> Result<GetLexiconOutput, RusotoError<GetLexiconError>> {
let request_uri = format!("/v1/lexicons/{lexicon_name}", lexicon_name = input.name);
let mut request = SignedRequest::new("GET", "polly", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetLexiconOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetLexiconError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_speech_synthesis_task(
&self,
input: GetSpeechSynthesisTaskInput,
) -> Result<GetSpeechSynthesisTaskOutput, RusotoError<GetSpeechSynthesisTaskError>> {
let request_uri = format!("/v1/synthesisTasks/{task_id}", task_id = input.task_id);
let mut request = SignedRequest::new("GET", "polly", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetSpeechSynthesisTaskOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetSpeechSynthesisTaskError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_lexicons(
&self,
input: ListLexiconsInput,
) -> Result<ListLexiconsOutput, RusotoError<ListLexiconsError>> {
let request_uri = "/v1/lexicons";
let mut request = SignedRequest::new("GET", "polly", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListLexiconsOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListLexiconsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_speech_synthesis_tasks(
&self,
input: ListSpeechSynthesisTasksInput,
) -> Result<ListSpeechSynthesisTasksOutput, RusotoError<ListSpeechSynthesisTasksError>> {
let request_uri = "/v1/synthesisTasks";
let mut request = SignedRequest::new("GET", "polly", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("MaxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
if let Some(ref x) = input.status {
params.put("Status", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListSpeechSynthesisTasksOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListSpeechSynthesisTasksError::from_response(response))
}
}
#[allow(unused_mut)]
async fn put_lexicon(
&self,
input: PutLexiconInput,
) -> Result<PutLexiconOutput, RusotoError<PutLexiconError>> {
let request_uri = format!("/v1/lexicons/{lexicon_name}", lexicon_name = input.name);
let mut request = SignedRequest::new("PUT", "polly", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PutLexiconOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutLexiconError::from_response(response))
}
}
#[allow(unused_mut)]
async fn start_speech_synthesis_task(
&self,
input: StartSpeechSynthesisTaskInput,
) -> Result<StartSpeechSynthesisTaskOutput, RusotoError<StartSpeechSynthesisTaskError>> {
let request_uri = "/v1/synthesisTasks";
let mut request = SignedRequest::new("POST", "polly", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<StartSpeechSynthesisTaskOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(StartSpeechSynthesisTaskError::from_response(response))
}
}
#[allow(unused_mut)]
async fn synthesize_speech(
&self,
input: SynthesizeSpeechInput,
) -> Result<SynthesizeSpeechOutput, RusotoError<SynthesizeSpeechError>> {
let request_uri = "/v1/speech";
let mut request = SignedRequest::new("POST", "polly", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let mut result = SynthesizeSpeechOutput::default();
result.audio_stream = Some(response.body);
result.content_type = response.headers.remove("Content-Type");
result.request_characters = response
.headers
.remove("x-amzn-RequestCharacters")
.map(|value| value.parse::<i64>().unwrap());
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(SynthesizeSpeechError::from_response(response))
}
}
}