SynthesisTask.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/polly/Polly_EXPORTS.h>
#include <aws/polly/model/Engine.h>
#include <aws/polly/model/LanguageCode.h>
#include <aws/polly/model/OutputFormat.h>
#include <aws/polly/model/SpeechMarkType.h>
#include <aws/polly/model/TaskStatus.h>
#include <aws/polly/model/TextType.h>
#include <aws/polly/model/VoiceId.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Polly {
namespace Model {
 
class SynthesisTask {
 public:
  AWS_POLLY_API SynthesisTask() = default;
  AWS_POLLY_API SynthesisTask(Aws::Utils::Json::JsonView jsonValue);
  AWS_POLLY_API SynthesisTask& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_POLLY_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline Engine GetEngine() const { return m_engine; }
  inline bool EngineHasBeenSet() const { return m_engineHasBeenSet; }
  inline void SetEngine(Engine value) {
    m_engineHasBeenSet = true;
    m_engine = value;
  }
  inline SynthesisTask& WithEngine(Engine value) {
    SetEngine(value);
    return *this;
  }
 
 
  inline const Aws::String& GetTaskId() const { return m_taskId; }
  inline bool TaskIdHasBeenSet() const { return m_taskIdHasBeenSet; }
  template <typename TaskIdT = Aws::String>
  void SetTaskId(TaskIdT&& value) {
    m_taskIdHasBeenSet = true;
    m_taskId = std::forward<TaskIdT>(value);
  }
  template <typename TaskIdT = Aws::String>
  SynthesisTask& WithTaskId(TaskIdT&& value) {
    SetTaskId(std::forward<TaskIdT>(value));
    return *this;
  }
 
 
  inline TaskStatus GetTaskStatus() const { return m_taskStatus; }
  inline bool TaskStatusHasBeenSet() const { return m_taskStatusHasBeenSet; }
  inline void SetTaskStatus(TaskStatus value) {
    m_taskStatusHasBeenSet = true;
    m_taskStatus = value;
  }
  inline SynthesisTask& WithTaskStatus(TaskStatus value) {
    SetTaskStatus(value);
    return *this;
  }
 
 
  inline const Aws::String& GetTaskStatusReason() const { return m_taskStatusReason; }
  inline bool TaskStatusReasonHasBeenSet() const { return m_taskStatusReasonHasBeenSet; }
  template <typename TaskStatusReasonT = Aws::String>
  void SetTaskStatusReason(TaskStatusReasonT&& value) {
    m_taskStatusReasonHasBeenSet = true;
    m_taskStatusReason = std::forward<TaskStatusReasonT>(value);
  }
  template <typename TaskStatusReasonT = Aws::String>
  SynthesisTask& WithTaskStatusReason(TaskStatusReasonT&& value) {
    SetTaskStatusReason(std::forward<TaskStatusReasonT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetOutputUri() const { return m_outputUri; }
  inline bool OutputUriHasBeenSet() const { return m_outputUriHasBeenSet; }
  template <typename OutputUriT = Aws::String>
  void SetOutputUri(OutputUriT&& value) {
    m_outputUriHasBeenSet = true;
    m_outputUri = std::forward<OutputUriT>(value);
  }
  template <typename OutputUriT = Aws::String>
  SynthesisTask& WithOutputUri(OutputUriT&& value) {
    SetOutputUri(std::forward<OutputUriT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCreationTime() const { return m_creationTime; }
  inline bool CreationTimeHasBeenSet() const { return m_creationTimeHasBeenSet; }
  template <typename CreationTimeT = Aws::Utils::DateTime>
  void SetCreationTime(CreationTimeT&& value) {
    m_creationTimeHasBeenSet = true;
    m_creationTime = std::forward<CreationTimeT>(value);
  }
  template <typename CreationTimeT = Aws::Utils::DateTime>
  SynthesisTask& WithCreationTime(CreationTimeT&& value) {
    SetCreationTime(std::forward<CreationTimeT>(value));
    return *this;
  }
 
 
  inline int GetRequestCharacters() const { return m_requestCharacters; }
  inline bool RequestCharactersHasBeenSet() const { return m_requestCharactersHasBeenSet; }
  inline void SetRequestCharacters(int value) {
    m_requestCharactersHasBeenSet = true;
    m_requestCharacters = value;
  }
  inline SynthesisTask& WithRequestCharacters(int value) {
    SetRequestCharacters(value);
    return *this;
  }
 
 
  inline const Aws::String& GetSnsTopicArn() const { return m_snsTopicArn; }
  inline bool SnsTopicArnHasBeenSet() const { return m_snsTopicArnHasBeenSet; }
  template <typename SnsTopicArnT = Aws::String>
  void SetSnsTopicArn(SnsTopicArnT&& value) {
    m_snsTopicArnHasBeenSet = true;
    m_snsTopicArn = std::forward<SnsTopicArnT>(value);
  }
  template <typename SnsTopicArnT = Aws::String>
  SynthesisTask& WithSnsTopicArn(SnsTopicArnT&& value) {
    SetSnsTopicArn(std::forward<SnsTopicArnT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetLexiconNames() const { return m_lexiconNames; }
  inline bool LexiconNamesHasBeenSet() const { return m_lexiconNamesHasBeenSet; }
  template <typename LexiconNamesT = Aws::Vector<Aws::String>>
  void SetLexiconNames(LexiconNamesT&& value) {
    m_lexiconNamesHasBeenSet = true;
    m_lexiconNames = std::forward<LexiconNamesT>(value);
  }
  template <typename LexiconNamesT = Aws::Vector<Aws::String>>
  SynthesisTask& WithLexiconNames(LexiconNamesT&& value) {
    SetLexiconNames(std::forward<LexiconNamesT>(value));
    return *this;
  }
  template <typename LexiconNamesT = Aws::String>
  SynthesisTask& AddLexiconNames(LexiconNamesT&& value) {
    m_lexiconNamesHasBeenSet = true;
    m_lexiconNames.emplace_back(std::forward<LexiconNamesT>(value));
    return *this;
  }
 
 
  inline OutputFormat GetOutputFormat() const { return m_outputFormat; }
  inline bool OutputFormatHasBeenSet() const { return m_outputFormatHasBeenSet; }
  inline void SetOutputFormat(OutputFormat value) {
    m_outputFormatHasBeenSet = true;
    m_outputFormat = value;
  }
  inline SynthesisTask& WithOutputFormat(OutputFormat value) {
    SetOutputFormat(value);
    return *this;
  }
 
 
  inline const Aws::String& GetSampleRate() const { return m_sampleRate; }
  inline bool SampleRateHasBeenSet() const { return m_sampleRateHasBeenSet; }
  template <typename SampleRateT = Aws::String>
  void SetSampleRate(SampleRateT&& value) {
    m_sampleRateHasBeenSet = true;
    m_sampleRate = std::forward<SampleRateT>(value);
  }
  template <typename SampleRateT = Aws::String>
  SynthesisTask& WithSampleRate(SampleRateT&& value) {
    SetSampleRate(std::forward<SampleRateT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<SpeechMarkType>& GetSpeechMarkTypes() const { return m_speechMarkTypes; }
  inline bool SpeechMarkTypesHasBeenSet() const { return m_speechMarkTypesHasBeenSet; }
  template <typename SpeechMarkTypesT = Aws::Vector<SpeechMarkType>>
  void SetSpeechMarkTypes(SpeechMarkTypesT&& value) {
    m_speechMarkTypesHasBeenSet = true;
    m_speechMarkTypes = std::forward<SpeechMarkTypesT>(value);
  }
  template <typename SpeechMarkTypesT = Aws::Vector<SpeechMarkType>>
  SynthesisTask& WithSpeechMarkTypes(SpeechMarkTypesT&& value) {
    SetSpeechMarkTypes(std::forward<SpeechMarkTypesT>(value));
    return *this;
  }
  inline SynthesisTask& AddSpeechMarkTypes(SpeechMarkType value) {
    m_speechMarkTypesHasBeenSet = true;
    m_speechMarkTypes.push_back(value);
    return *this;
  }
 
 
  inline TextType GetTextType() const { return m_textType; }
  inline bool TextTypeHasBeenSet() const { return m_textTypeHasBeenSet; }
  inline void SetTextType(TextType value) {
    m_textTypeHasBeenSet = true;
    m_textType = value;
  }
  inline SynthesisTask& WithTextType(TextType value) {
    SetTextType(value);
    return *this;
  }
 
 
  inline VoiceId GetVoiceId() const { return m_voiceId; }
  inline bool VoiceIdHasBeenSet() const { return m_voiceIdHasBeenSet; }
  inline void SetVoiceId(VoiceId value) {
    m_voiceIdHasBeenSet = true;
    m_voiceId = value;
  }
  inline SynthesisTask& WithVoiceId(VoiceId value) {
    SetVoiceId(value);
    return *this;
  }
 
 
  inline LanguageCode GetLanguageCode() const { return m_languageCode; }
  inline bool LanguageCodeHasBeenSet() const { return m_languageCodeHasBeenSet; }
  inline void SetLanguageCode(LanguageCode value) {
    m_languageCodeHasBeenSet = true;
    m_languageCode = value;
  }
  inline SynthesisTask& WithLanguageCode(LanguageCode value) {
    SetLanguageCode(value);
    return *this;
  }
 private:
  Engine m_engine{Engine::NOT_SET};
 
  Aws::String m_taskId;
 
  TaskStatus m_taskStatus{TaskStatus::NOT_SET};
 
  Aws::String m_taskStatusReason;
 
  Aws::String m_outputUri;
 
  Aws::Utils::DateTime m_creationTime{};
 
  int m_requestCharacters{0};
 
  Aws::String m_snsTopicArn;
 
  Aws::Vector<Aws::String> m_lexiconNames;
 
  OutputFormat m_outputFormat{OutputFormat::NOT_SET};
 
  Aws::String m_sampleRate;
 
  Aws::Vector<SpeechMarkType> m_speechMarkTypes;
 
  TextType m_textType{TextType::NOT_SET};
 
  VoiceId m_voiceId{VoiceId::NOT_SET};
 
  LanguageCode m_languageCode{LanguageCode::NOT_SET};
  bool m_engineHasBeenSet = false;
  bool m_taskIdHasBeenSet = false;
  bool m_taskStatusHasBeenSet = false;
  bool m_taskStatusReasonHasBeenSet = false;
  bool m_outputUriHasBeenSet = false;
  bool m_creationTimeHasBeenSet = false;
  bool m_requestCharactersHasBeenSet = false;
  bool m_snsTopicArnHasBeenSet = false;
  bool m_lexiconNamesHasBeenSet = false;
  bool m_outputFormatHasBeenSet = false;
  bool m_sampleRateHasBeenSet = false;
  bool m_speechMarkTypesHasBeenSet = false;
  bool m_textTypeHasBeenSet = false;
  bool m_voiceIdHasBeenSet = false;
  bool m_languageCodeHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Polly
}  // namespace Aws