CallAnalyticsTranscriptResultStream.h

 
#pragma once
#include <aws/transcribestreaming/TranscribeStreamingService_EXPORTS.h>
#include <aws/transcribestreaming/model/CategoryEvent.h>
#include <aws/transcribestreaming/model/UtteranceEvent.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace TranscribeStreamingService {
namespace Model {
 
class CallAnalyticsTranscriptResultStream {
 public:
  AWS_TRANSCRIBESTREAMINGSERVICE_API CallAnalyticsTranscriptResultStream() = default;
  AWS_TRANSCRIBESTREAMINGSERVICE_API CallAnalyticsTranscriptResultStream(Aws::Utils::Json::JsonView jsonValue);
  AWS_TRANSCRIBESTREAMINGSERVICE_API CallAnalyticsTranscriptResultStream& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_TRANSCRIBESTREAMINGSERVICE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const UtteranceEvent& GetUtteranceEvent() const { return m_utteranceEvent; }
  inline bool UtteranceEventHasBeenSet() const { return m_utteranceEventHasBeenSet; }
  template <typename UtteranceEventT = UtteranceEvent>
  void SetUtteranceEvent(UtteranceEventT&& value) {
    m_utteranceEventHasBeenSet = true;
    m_utteranceEvent = std::forward<UtteranceEventT>(value);
  }
  template <typename UtteranceEventT = UtteranceEvent>
  CallAnalyticsTranscriptResultStream& WithUtteranceEvent(UtteranceEventT&& value) {
    SetUtteranceEvent(std::forward<UtteranceEventT>(value));
    return *this;
  }
 
 
  inline const CategoryEvent& GetCategoryEvent() const { return m_categoryEvent; }
  inline bool CategoryEventHasBeenSet() const { return m_categoryEventHasBeenSet; }
  template <typename CategoryEventT = CategoryEvent>
  void SetCategoryEvent(CategoryEventT&& value) {
    m_categoryEventHasBeenSet = true;
    m_categoryEvent = std::forward<CategoryEventT>(value);
  }
  template <typename CategoryEventT = CategoryEvent>
  CallAnalyticsTranscriptResultStream& WithCategoryEvent(CategoryEventT&& value) {
    SetCategoryEvent(std::forward<CategoryEventT>(value));
    return *this;
  }
 
 
  inline const TranscribeStreamingServiceError& GetBadRequestException() const { return m_badRequestException; }
  inline bool BadRequestExceptionHasBeenSet() const { return m_badRequestExceptionHasBeenSet; }
  template <typename BadRequestExceptionT = TranscribeStreamingServiceError>
  void SetBadRequestException(BadRequestExceptionT&& value) {
    m_badRequestExceptionHasBeenSet = true;
    m_badRequestException = std::forward<BadRequestExceptionT>(value);
  }
  template <typename BadRequestExceptionT = TranscribeStreamingServiceError>
  CallAnalyticsTranscriptResultStream& WithBadRequestException(BadRequestExceptionT&& value) {
    SetBadRequestException(std::forward<BadRequestExceptionT>(value));
    return *this;
  }
 
 
  inline const TranscribeStreamingServiceError& GetLimitExceededException() const { return m_limitExceededException; }
  inline bool LimitExceededExceptionHasBeenSet() const { return m_limitExceededExceptionHasBeenSet; }
  template <typename LimitExceededExceptionT = TranscribeStreamingServiceError>
  void SetLimitExceededException(LimitExceededExceptionT&& value) {
    m_limitExceededExceptionHasBeenSet = true;
    m_limitExceededException = std::forward<LimitExceededExceptionT>(value);
  }
  template <typename LimitExceededExceptionT = TranscribeStreamingServiceError>
  CallAnalyticsTranscriptResultStream& WithLimitExceededException(LimitExceededExceptionT&& value) {
    SetLimitExceededException(std::forward<LimitExceededExceptionT>(value));
    return *this;
  }
 
 
  inline const TranscribeStreamingServiceError& GetInternalFailureException() const { return m_internalFailureException; }
  inline bool InternalFailureExceptionHasBeenSet() const { return m_internalFailureExceptionHasBeenSet; }
  template <typename InternalFailureExceptionT = TranscribeStreamingServiceError>
  void SetInternalFailureException(InternalFailureExceptionT&& value) {
    m_internalFailureExceptionHasBeenSet = true;
    m_internalFailureException = std::forward<InternalFailureExceptionT>(value);
  }
  template <typename InternalFailureExceptionT = TranscribeStreamingServiceError>
  CallAnalyticsTranscriptResultStream& WithInternalFailureException(InternalFailureExceptionT&& value) {
    SetInternalFailureException(std::forward<InternalFailureExceptionT>(value));
    return *this;
  }
 
 
  inline const TranscribeStreamingServiceError& GetConflictException() const { return m_conflictException; }
  inline bool ConflictExceptionHasBeenSet() const { return m_conflictExceptionHasBeenSet; }
  template <typename ConflictExceptionT = TranscribeStreamingServiceError>
  void SetConflictException(ConflictExceptionT&& value) {
    m_conflictExceptionHasBeenSet = true;
    m_conflictException = std::forward<ConflictExceptionT>(value);
  }
  template <typename ConflictExceptionT = TranscribeStreamingServiceError>
  CallAnalyticsTranscriptResultStream& WithConflictException(ConflictExceptionT&& value) {
    SetConflictException(std::forward<ConflictExceptionT>(value));
    return *this;
  }
 
 
  inline const TranscribeStreamingServiceError& GetServiceUnavailableException() const { return m_serviceUnavailableException; }
  inline bool ServiceUnavailableExceptionHasBeenSet() const { return m_serviceUnavailableExceptionHasBeenSet; }
  template <typename ServiceUnavailableExceptionT = TranscribeStreamingServiceError>
  void SetServiceUnavailableException(ServiceUnavailableExceptionT&& value) {
    m_serviceUnavailableExceptionHasBeenSet = true;
    m_serviceUnavailableException = std::forward<ServiceUnavailableExceptionT>(value);
  }
  template <typename ServiceUnavailableExceptionT = TranscribeStreamingServiceError>
  CallAnalyticsTranscriptResultStream& WithServiceUnavailableException(ServiceUnavailableExceptionT&& value) {
    SetServiceUnavailableException(std::forward<ServiceUnavailableExceptionT>(value));
    return *this;
  }
 private:
  UtteranceEvent m_utteranceEvent;
 
  CategoryEvent m_categoryEvent;
 
  TranscribeStreamingServiceError m_badRequestException;
 
  TranscribeStreamingServiceError m_limitExceededException;
 
  TranscribeStreamingServiceError m_internalFailureException;
 
  TranscribeStreamingServiceError m_conflictException;
 
  TranscribeStreamingServiceError m_serviceUnavailableException;
  bool m_utteranceEventHasBeenSet = false;
  bool m_categoryEventHasBeenSet = false;
  bool m_badRequestExceptionHasBeenSet = false;
  bool m_limitExceededExceptionHasBeenSet = false;
  bool m_internalFailureExceptionHasBeenSet = false;
  bool m_conflictExceptionHasBeenSet = false;
  bool m_serviceUnavailableExceptionHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace TranscribeStreamingService
}  // namespace Aws