StartStreamTranscriptionRequest.h

 
#pragma once
#include <aws/core/utils/event/EventStreamDecoder.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/transcribestreaming/TranscribeStreamingServiceRequest.h>
#include <aws/transcribestreaming/TranscribeStreamingService_EXPORTS.h>
#include <aws/transcribestreaming/model/AudioStream.h>
#include <aws/transcribestreaming/model/ContentIdentificationType.h>
#include <aws/transcribestreaming/model/ContentRedactionType.h>
#include <aws/transcribestreaming/model/LanguageCode.h>
#include <aws/transcribestreaming/model/MediaEncoding.h>
#include <aws/transcribestreaming/model/PartialResultsStability.h>
#include <aws/transcribestreaming/model/StartStreamTranscriptionHandler.h>
#include <aws/transcribestreaming/model/VocabularyFilterMethod.h>
 
#include <memory>
#include <utility>
 
namespace Aws {
namespace TranscribeStreamingService {
namespace Model {
 
class StartStreamTranscriptionRequest : public TranscribeStreamingServiceRequest {
 public:
  AWS_TRANSCRIBESTREAMINGSERVICE_API StartStreamTranscriptionRequest() = default;
 
  // Service request name is the Operation name which will send this request out,
  // each operation should has unique request name, so that we can get operation's name from this request.
  // Note: this is not true for response, multiple operations may have the same response name,
  // so we can not get operation's name from response.
  inline virtual const char* GetServiceRequestName() const override { return "StartStreamTranscription"; }
 
  inline virtual bool IsEventStreamRequest() const override { return true; }
  inline virtual bool HasEventStreamResponse() const override { return true; }
  // SerializePayload will not be invoked.
  // This request is sent by encoding its data in event-streams which is sent as IOStream via GetBody()
  AWS_TRANSCRIBESTREAMINGSERVICE_API Aws::String SerializePayload() const override { return {}; }
  AWS_TRANSCRIBESTREAMINGSERVICE_API std::shared_ptr<Aws::IOStream> GetBody() const override;
  AWS_TRANSCRIBESTREAMINGSERVICE_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
 
  inline Aws::Utils::Event::EventStreamDecoder& GetEventStreamDecoder() { return m_decoder; }
 
  inline StartStreamTranscriptionHandler& GetEventStreamHandler() { return m_handler; }
 
  inline void SetEventStreamHandler(const StartStreamTranscriptionHandler& value) {
    m_handler = value;
    m_decoder.ResetEventStreamHandler(&m_handler);
  }
 
  inline StartStreamTranscriptionRequest& WithEventStreamHandler(const StartStreamTranscriptionHandler& value) {
    SetEventStreamHandler(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 StartStreamTranscriptionRequest& WithLanguageCode(LanguageCode value) {
    SetLanguageCode(value);
    return *this;
  }
 
 
  inline int GetMediaSampleRateHertz() const { return m_mediaSampleRateHertz; }
  inline bool MediaSampleRateHertzHasBeenSet() const { return m_mediaSampleRateHertzHasBeenSet; }
  inline void SetMediaSampleRateHertz(int value) {
    m_mediaSampleRateHertzHasBeenSet = true;
    m_mediaSampleRateHertz = value;
  }
  inline StartStreamTranscriptionRequest& WithMediaSampleRateHertz(int value) {
    SetMediaSampleRateHertz(value);
    return *this;
  }
 
 
  inline MediaEncoding GetMediaEncoding() const { return m_mediaEncoding; }
  inline bool MediaEncodingHasBeenSet() const { return m_mediaEncodingHasBeenSet; }
  inline void SetMediaEncoding(MediaEncoding value) {
    m_mediaEncodingHasBeenSet = true;
    m_mediaEncoding = value;
  }
  inline StartStreamTranscriptionRequest& WithMediaEncoding(MediaEncoding value) {
    SetMediaEncoding(value);
    return *this;
  }
 
 
  inline const Aws::String& GetVocabularyName() const { return m_vocabularyName; }
  inline bool VocabularyNameHasBeenSet() const { return m_vocabularyNameHasBeenSet; }
  template <typename VocabularyNameT = Aws::String>
  void SetVocabularyName(VocabularyNameT&& value) {
    m_vocabularyNameHasBeenSet = true;
    m_vocabularyName = std::forward<VocabularyNameT>(value);
  }
  template <typename VocabularyNameT = Aws::String>
  StartStreamTranscriptionRequest& WithVocabularyName(VocabularyNameT&& value) {
    SetVocabularyName(std::forward<VocabularyNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSessionId() const { return m_sessionId; }
  inline bool SessionIdHasBeenSet() const { return m_sessionIdHasBeenSet; }
  template <typename SessionIdT = Aws::String>
  void SetSessionId(SessionIdT&& value) {
    m_sessionIdHasBeenSet = true;
    m_sessionId = std::forward<SessionIdT>(value);
  }
  template <typename SessionIdT = Aws::String>
  StartStreamTranscriptionRequest& WithSessionId(SessionIdT&& value) {
    SetSessionId(std::forward<SessionIdT>(value));
    return *this;
  }
 
 
  AWS_TRANSCRIBESTREAMINGSERVICE_API std::shared_ptr<AudioStream> GetAudioStream() const { return m_audioStream; }
  AWS_TRANSCRIBESTREAMINGSERVICE_API void SetAudioStream(const std::shared_ptr<AudioStream>& value) {
    m_audioStreamHasBeenSet = true;
    m_audioStream = value;
  }
  AWS_TRANSCRIBESTREAMINGSERVICE_API StartStreamTranscriptionRequest& WithAudioStream(const std::shared_ptr<AudioStream>& value) {
    SetAudioStream(value);
    return *this;
  }
 
 
 
  inline const Aws::String& GetVocabularyFilterName() const { return m_vocabularyFilterName; }
  inline bool VocabularyFilterNameHasBeenSet() const { return m_vocabularyFilterNameHasBeenSet; }
  template <typename VocabularyFilterNameT = Aws::String>
  void SetVocabularyFilterName(VocabularyFilterNameT&& value) {
    m_vocabularyFilterNameHasBeenSet = true;
    m_vocabularyFilterName = std::forward<VocabularyFilterNameT>(value);
  }
  template <typename VocabularyFilterNameT = Aws::String>
  StartStreamTranscriptionRequest& WithVocabularyFilterName(VocabularyFilterNameT&& value) {
    SetVocabularyFilterName(std::forward<VocabularyFilterNameT>(value));
    return *this;
  }
 
 
  inline VocabularyFilterMethod GetVocabularyFilterMethod() const { return m_vocabularyFilterMethod; }
  inline bool VocabularyFilterMethodHasBeenSet() const { return m_vocabularyFilterMethodHasBeenSet; }
  inline void SetVocabularyFilterMethod(VocabularyFilterMethod value) {
    m_vocabularyFilterMethodHasBeenSet = true;
    m_vocabularyFilterMethod = value;
  }
  inline StartStreamTranscriptionRequest& WithVocabularyFilterMethod(VocabularyFilterMethod value) {
    SetVocabularyFilterMethod(value);
    return *this;
  }
 
 
  inline bool GetShowSpeakerLabel() const { return m_showSpeakerLabel; }
  inline bool ShowSpeakerLabelHasBeenSet() const { return m_showSpeakerLabelHasBeenSet; }
  inline void SetShowSpeakerLabel(bool value) {
    m_showSpeakerLabelHasBeenSet = true;
    m_showSpeakerLabel = value;
  }
  inline StartStreamTranscriptionRequest& WithShowSpeakerLabel(bool value) {
    SetShowSpeakerLabel(value);
    return *this;
  }
 
 
  inline bool GetEnableChannelIdentification() const { return m_enableChannelIdentification; }
  inline bool EnableChannelIdentificationHasBeenSet() const { return m_enableChannelIdentificationHasBeenSet; }
  inline void SetEnableChannelIdentification(bool value) {
    m_enableChannelIdentificationHasBeenSet = true;
    m_enableChannelIdentification = value;
  }
  inline StartStreamTranscriptionRequest& WithEnableChannelIdentification(bool value) {
    SetEnableChannelIdentification(value);
    return *this;
  }
 
 
  inline int GetNumberOfChannels() const { return m_numberOfChannels; }
  inline bool NumberOfChannelsHasBeenSet() const { return m_numberOfChannelsHasBeenSet; }
  inline void SetNumberOfChannels(int value) {
    m_numberOfChannelsHasBeenSet = true;
    m_numberOfChannels = value;
  }
  inline StartStreamTranscriptionRequest& WithNumberOfChannels(int value) {
    SetNumberOfChannels(value);
    return *this;
  }
 
 
  inline bool GetEnablePartialResultsStabilization() const { return m_enablePartialResultsStabilization; }
  inline bool EnablePartialResultsStabilizationHasBeenSet() const { return m_enablePartialResultsStabilizationHasBeenSet; }
  inline void SetEnablePartialResultsStabilization(bool value) {
    m_enablePartialResultsStabilizationHasBeenSet = true;
    m_enablePartialResultsStabilization = value;
  }
  inline StartStreamTranscriptionRequest& WithEnablePartialResultsStabilization(bool value) {
    SetEnablePartialResultsStabilization(value);
    return *this;
  }
 
 
  inline PartialResultsStability GetPartialResultsStability() const { return m_partialResultsStability; }
  inline bool PartialResultsStabilityHasBeenSet() const { return m_partialResultsStabilityHasBeenSet; }
  inline void SetPartialResultsStability(PartialResultsStability value) {
    m_partialResultsStabilityHasBeenSet = true;
    m_partialResultsStability = value;
  }
  inline StartStreamTranscriptionRequest& WithPartialResultsStability(PartialResultsStability value) {
    SetPartialResultsStability(value);
    return *this;
  }
 
 
  inline ContentIdentificationType GetContentIdentificationType() const { return m_contentIdentificationType; }
  inline bool ContentIdentificationTypeHasBeenSet() const { return m_contentIdentificationTypeHasBeenSet; }
  inline void SetContentIdentificationType(ContentIdentificationType value) {
    m_contentIdentificationTypeHasBeenSet = true;
    m_contentIdentificationType = value;
  }
  inline StartStreamTranscriptionRequest& WithContentIdentificationType(ContentIdentificationType value) {
    SetContentIdentificationType(value);
    return *this;
  }
 
 
  inline ContentRedactionType GetContentRedactionType() const { return m_contentRedactionType; }
  inline bool ContentRedactionTypeHasBeenSet() const { return m_contentRedactionTypeHasBeenSet; }
  inline void SetContentRedactionType(ContentRedactionType value) {
    m_contentRedactionTypeHasBeenSet = true;
    m_contentRedactionType = value;
  }
  inline StartStreamTranscriptionRequest& WithContentRedactionType(ContentRedactionType value) {
    SetContentRedactionType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetPiiEntityTypes() const { return m_piiEntityTypes; }
  inline bool PiiEntityTypesHasBeenSet() const { return m_piiEntityTypesHasBeenSet; }
  template <typename PiiEntityTypesT = Aws::String>
  void SetPiiEntityTypes(PiiEntityTypesT&& value) {
    m_piiEntityTypesHasBeenSet = true;
    m_piiEntityTypes = std::forward<PiiEntityTypesT>(value);
  }
  template <typename PiiEntityTypesT = Aws::String>
  StartStreamTranscriptionRequest& WithPiiEntityTypes(PiiEntityTypesT&& value) {
    SetPiiEntityTypes(std::forward<PiiEntityTypesT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetLanguageModelName() const { return m_languageModelName; }
  inline bool LanguageModelNameHasBeenSet() const { return m_languageModelNameHasBeenSet; }
  template <typename LanguageModelNameT = Aws::String>
  void SetLanguageModelName(LanguageModelNameT&& value) {
    m_languageModelNameHasBeenSet = true;
    m_languageModelName = std::forward<LanguageModelNameT>(value);
  }
  template <typename LanguageModelNameT = Aws::String>
  StartStreamTranscriptionRequest& WithLanguageModelName(LanguageModelNameT&& value) {
    SetLanguageModelName(std::forward<LanguageModelNameT>(value));
    return *this;
  }
 
 
  inline bool GetIdentifyLanguage() const { return m_identifyLanguage; }
  inline bool IdentifyLanguageHasBeenSet() const { return m_identifyLanguageHasBeenSet; }
  inline void SetIdentifyLanguage(bool value) {
    m_identifyLanguageHasBeenSet = true;
    m_identifyLanguage = value;
  }
  inline StartStreamTranscriptionRequest& WithIdentifyLanguage(bool value) {
    SetIdentifyLanguage(value);
    return *this;
  }
 
 
  inline const Aws::String& GetLanguageOptions() const { return m_languageOptions; }
  inline bool LanguageOptionsHasBeenSet() const { return m_languageOptionsHasBeenSet; }
  template <typename LanguageOptionsT = Aws::String>
  void SetLanguageOptions(LanguageOptionsT&& value) {
    m_languageOptionsHasBeenSet = true;
    m_languageOptions = std::forward<LanguageOptionsT>(value);
  }
  template <typename LanguageOptionsT = Aws::String>
  StartStreamTranscriptionRequest& WithLanguageOptions(LanguageOptionsT&& value) {
    SetLanguageOptions(std::forward<LanguageOptionsT>(value));
    return *this;
  }
 
 
  inline LanguageCode GetPreferredLanguage() const { return m_preferredLanguage; }
  inline bool PreferredLanguageHasBeenSet() const { return m_preferredLanguageHasBeenSet; }
  inline void SetPreferredLanguage(LanguageCode value) {
    m_preferredLanguageHasBeenSet = true;
    m_preferredLanguage = value;
  }
  inline StartStreamTranscriptionRequest& WithPreferredLanguage(LanguageCode value) {
    SetPreferredLanguage(value);
    return *this;
  }
 
 
  inline bool GetIdentifyMultipleLanguages() const { return m_identifyMultipleLanguages; }
  inline bool IdentifyMultipleLanguagesHasBeenSet() const { return m_identifyMultipleLanguagesHasBeenSet; }
  inline void SetIdentifyMultipleLanguages(bool value) {
    m_identifyMultipleLanguagesHasBeenSet = true;
    m_identifyMultipleLanguages = value;
  }
  inline StartStreamTranscriptionRequest& WithIdentifyMultipleLanguages(bool value) {
    SetIdentifyMultipleLanguages(value);
    return *this;
  }
 
 
  inline const Aws::String& GetVocabularyNames() const { return m_vocabularyNames; }
  inline bool VocabularyNamesHasBeenSet() const { return m_vocabularyNamesHasBeenSet; }
  template <typename VocabularyNamesT = Aws::String>
  void SetVocabularyNames(VocabularyNamesT&& value) {
    m_vocabularyNamesHasBeenSet = true;
    m_vocabularyNames = std::forward<VocabularyNamesT>(value);
  }
  template <typename VocabularyNamesT = Aws::String>
  StartStreamTranscriptionRequest& WithVocabularyNames(VocabularyNamesT&& value) {
    SetVocabularyNames(std::forward<VocabularyNamesT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetVocabularyFilterNames() const { return m_vocabularyFilterNames; }
  inline bool VocabularyFilterNamesHasBeenSet() const { return m_vocabularyFilterNamesHasBeenSet; }
  template <typename VocabularyFilterNamesT = Aws::String>
  void SetVocabularyFilterNames(VocabularyFilterNamesT&& value) {
    m_vocabularyFilterNamesHasBeenSet = true;
    m_vocabularyFilterNames = std::forward<VocabularyFilterNamesT>(value);
  }
  template <typename VocabularyFilterNamesT = Aws::String>
  StartStreamTranscriptionRequest& WithVocabularyFilterNames(VocabularyFilterNamesT&& value) {
    SetVocabularyFilterNames(std::forward<VocabularyFilterNamesT>(value));
    return *this;
  }
 
 
  inline int GetSessionResumeWindow() const { return m_sessionResumeWindow; }
  inline bool SessionResumeWindowHasBeenSet() const { return m_sessionResumeWindowHasBeenSet; }
  inline void SetSessionResumeWindow(int value) {
    m_sessionResumeWindowHasBeenSet = true;
    m_sessionResumeWindow = value;
  }
  inline StartStreamTranscriptionRequest& WithSessionResumeWindow(int value) {
    SetSessionResumeWindow(value);
    return *this;
  }
 private:
  LanguageCode m_languageCode{LanguageCode::NOT_SET};
 
  int m_mediaSampleRateHertz{0};
 
  MediaEncoding m_mediaEncoding{MediaEncoding::NOT_SET};
 
  Aws::String m_vocabularyName;
 
  Aws::String m_sessionId;
 
  std::shared_ptr<AudioStream> m_audioStream;
 
  Aws::String m_vocabularyFilterName;
 
  VocabularyFilterMethod m_vocabularyFilterMethod{VocabularyFilterMethod::NOT_SET};
 
  bool m_showSpeakerLabel{false};
 
  bool m_enableChannelIdentification{false};
 
  int m_numberOfChannels{0};
 
  bool m_enablePartialResultsStabilization{false};
 
  PartialResultsStability m_partialResultsStability{PartialResultsStability::NOT_SET};
 
  ContentIdentificationType m_contentIdentificationType{ContentIdentificationType::NOT_SET};
 
  ContentRedactionType m_contentRedactionType{ContentRedactionType::NOT_SET};
 
  Aws::String m_piiEntityTypes;
 
  Aws::String m_languageModelName;
 
  bool m_identifyLanguage{false};
 
  Aws::String m_languageOptions;
 
  LanguageCode m_preferredLanguage{LanguageCode::NOT_SET};
 
  bool m_identifyMultipleLanguages{false};
 
  Aws::String m_vocabularyNames;
 
  Aws::String m_vocabularyFilterNames;
 
  int m_sessionResumeWindow{0};
  StartStreamTranscriptionHandler m_handler;
  Aws::Utils::Event::EventStreamDecoder m_decoder{Utils::Event::EventStreamDecoder(&m_handler)};
 
  bool m_languageCodeHasBeenSet = false;
  bool m_mediaSampleRateHertzHasBeenSet = false;
  bool m_mediaEncodingHasBeenSet = false;
  bool m_vocabularyNameHasBeenSet = false;
  bool m_sessionIdHasBeenSet = false;
  bool m_audioStreamHasBeenSet = false;
  bool m_vocabularyFilterNameHasBeenSet = false;
  bool m_vocabularyFilterMethodHasBeenSet = false;
  bool m_showSpeakerLabelHasBeenSet = false;
  bool m_enableChannelIdentificationHasBeenSet = false;
  bool m_numberOfChannelsHasBeenSet = false;
  bool m_enablePartialResultsStabilizationHasBeenSet = false;
  bool m_partialResultsStabilityHasBeenSet = false;
  bool m_contentIdentificationTypeHasBeenSet = false;
  bool m_contentRedactionTypeHasBeenSet = false;
  bool m_piiEntityTypesHasBeenSet = false;
  bool m_languageModelNameHasBeenSet = false;
  bool m_identifyLanguageHasBeenSet = false;
  bool m_languageOptionsHasBeenSet = false;
  bool m_preferredLanguageHasBeenSet = false;
  bool m_identifyMultipleLanguagesHasBeenSet = false;
  bool m_vocabularyNamesHasBeenSet = false;
  bool m_vocabularyFilterNamesHasBeenSet = false;
  bool m_sessionResumeWindowHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace TranscribeStreamingService
}  // namespace Aws