StartStreamTranscriptionInitialResponse.h

 
#pragma once
#include <aws/core/http/HttpTypes.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/transcribestreaming/TranscribeStreamingService_EXPORTS.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/TranscriptFormat.h>
#include <aws/transcribestreaming/model/VocabularyFilterMethod.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace TranscribeStreamingService {
namespace Model {
 
class StartStreamTranscriptionInitialResponse {
 public:
  AWS_TRANSCRIBESTREAMINGSERVICE_API StartStreamTranscriptionInitialResponse() = default;
  AWS_TRANSCRIBESTREAMINGSERVICE_API StartStreamTranscriptionInitialResponse(Aws::Utils::Json::JsonView jsonValue);
  AWS_TRANSCRIBESTREAMINGSERVICE_API StartStreamTranscriptionInitialResponse& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_TRANSCRIBESTREAMINGSERVICE_API StartStreamTranscriptionInitialResponse(const Http::HeaderValueCollection& responseHeaders);
  AWS_TRANSCRIBESTREAMINGSERVICE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetRequestId() const { return m_requestId; }
  inline bool RequestIdHasBeenSet() const { return m_requestIdHasBeenSet; }
  template <typename RequestIdT = Aws::String>
  void SetRequestId(RequestIdT&& value) {
    m_requestIdHasBeenSet = true;
    m_requestId = std::forward<RequestIdT>(value);
  }
  template <typename RequestIdT = Aws::String>
  StartStreamTranscriptionInitialResponse& WithRequestId(RequestIdT&& value) {
    SetRequestId(std::forward<RequestIdT>(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 StartStreamTranscriptionInitialResponse& 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 StartStreamTranscriptionInitialResponse& 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 StartStreamTranscriptionInitialResponse& 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>
  StartStreamTranscriptionInitialResponse& 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>
  StartStreamTranscriptionInitialResponse& WithSessionId(SessionIdT&& value) {
    SetSessionId(std::forward<SessionIdT>(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>
  StartStreamTranscriptionInitialResponse& 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 StartStreamTranscriptionInitialResponse& 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 StartStreamTranscriptionInitialResponse& 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 StartStreamTranscriptionInitialResponse& 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 StartStreamTranscriptionInitialResponse& 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 StartStreamTranscriptionInitialResponse& 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 StartStreamTranscriptionInitialResponse& 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 StartStreamTranscriptionInitialResponse& 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 StartStreamTranscriptionInitialResponse& 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>
  StartStreamTranscriptionInitialResponse& 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>
  StartStreamTranscriptionInitialResponse& 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 StartStreamTranscriptionInitialResponse& 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>
  StartStreamTranscriptionInitialResponse& 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 StartStreamTranscriptionInitialResponse& 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 StartStreamTranscriptionInitialResponse& 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>
  StartStreamTranscriptionInitialResponse& 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>
  StartStreamTranscriptionInitialResponse& 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 StartStreamTranscriptionInitialResponse& WithSessionResumeWindow(int value) {
    SetSessionResumeWindow(value);
    return *this;
  }
 
 
  inline TranscriptFormat GetTranscriptFormat() const { return m_transcriptFormat; }
  inline bool TranscriptFormatHasBeenSet() const { return m_transcriptFormatHasBeenSet; }
  inline void SetTranscriptFormat(TranscriptFormat value) {
    m_transcriptFormatHasBeenSet = true;
    m_transcriptFormat = value;
  }
  inline StartStreamTranscriptionInitialResponse& WithTranscriptFormat(TranscriptFormat value) {
    SetTranscriptFormat(value);
    return *this;
  }
 private:
  Aws::String m_requestId;
 
  LanguageCode m_languageCode{LanguageCode::NOT_SET};
 
  int m_mediaSampleRateHertz{0};
 
  MediaEncoding m_mediaEncoding{MediaEncoding::NOT_SET};
 
  Aws::String m_vocabularyName;
 
  Aws::String m_sessionId;
 
  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};
 
  TranscriptFormat m_transcriptFormat{TranscriptFormat::NOT_SET};
  bool m_requestIdHasBeenSet = false;
  bool m_languageCodeHasBeenSet = false;
  bool m_mediaSampleRateHertzHasBeenSet = false;
  bool m_mediaEncodingHasBeenSet = false;
  bool m_vocabularyNameHasBeenSet = false;
  bool m_sessionIdHasBeenSet = 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;
  bool m_transcriptFormatHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace TranscribeStreamingService
}  // namespace Aws