Rule.h

 
#pragma once
#include <aws/transcribe/TranscribeService_EXPORTS.h>
#include <aws/transcribe/model/InterruptionFilter.h>
#include <aws/transcribe/model/NonTalkTimeFilter.h>
#include <aws/transcribe/model/SentimentFilter.h>
#include <aws/transcribe/model/TranscriptFilter.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace TranscribeService {
namespace Model {
 
class Rule {
 public:
  AWS_TRANSCRIBESERVICE_API Rule() = default;
  AWS_TRANSCRIBESERVICE_API Rule(Aws::Utils::Json::JsonView jsonValue);
  AWS_TRANSCRIBESERVICE_API Rule& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_TRANSCRIBESERVICE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const NonTalkTimeFilter& GetNonTalkTimeFilter() const { return m_nonTalkTimeFilter; }
  inline bool NonTalkTimeFilterHasBeenSet() const { return m_nonTalkTimeFilterHasBeenSet; }
  template <typename NonTalkTimeFilterT = NonTalkTimeFilter>
  void SetNonTalkTimeFilter(NonTalkTimeFilterT&& value) {
    m_nonTalkTimeFilterHasBeenSet = true;
    m_nonTalkTimeFilter = std::forward<NonTalkTimeFilterT>(value);
  }
  template <typename NonTalkTimeFilterT = NonTalkTimeFilter>
  Rule& WithNonTalkTimeFilter(NonTalkTimeFilterT&& value) {
    SetNonTalkTimeFilter(std::forward<NonTalkTimeFilterT>(value));
    return *this;
  }
 
 
  inline const InterruptionFilter& GetInterruptionFilter() const { return m_interruptionFilter; }
  inline bool InterruptionFilterHasBeenSet() const { return m_interruptionFilterHasBeenSet; }
  template <typename InterruptionFilterT = InterruptionFilter>
  void SetInterruptionFilter(InterruptionFilterT&& value) {
    m_interruptionFilterHasBeenSet = true;
    m_interruptionFilter = std::forward<InterruptionFilterT>(value);
  }
  template <typename InterruptionFilterT = InterruptionFilter>
  Rule& WithInterruptionFilter(InterruptionFilterT&& value) {
    SetInterruptionFilter(std::forward<InterruptionFilterT>(value));
    return *this;
  }
 
 
  inline const TranscriptFilter& GetTranscriptFilter() const { return m_transcriptFilter; }
  inline bool TranscriptFilterHasBeenSet() const { return m_transcriptFilterHasBeenSet; }
  template <typename TranscriptFilterT = TranscriptFilter>
  void SetTranscriptFilter(TranscriptFilterT&& value) {
    m_transcriptFilterHasBeenSet = true;
    m_transcriptFilter = std::forward<TranscriptFilterT>(value);
  }
  template <typename TranscriptFilterT = TranscriptFilter>
  Rule& WithTranscriptFilter(TranscriptFilterT&& value) {
    SetTranscriptFilter(std::forward<TranscriptFilterT>(value));
    return *this;
  }
 
 
  inline const SentimentFilter& GetSentimentFilter() const { return m_sentimentFilter; }
  inline bool SentimentFilterHasBeenSet() const { return m_sentimentFilterHasBeenSet; }
  template <typename SentimentFilterT = SentimentFilter>
  void SetSentimentFilter(SentimentFilterT&& value) {
    m_sentimentFilterHasBeenSet = true;
    m_sentimentFilter = std::forward<SentimentFilterT>(value);
  }
  template <typename SentimentFilterT = SentimentFilter>
  Rule& WithSentimentFilter(SentimentFilterT&& value) {
    SetSentimentFilter(std::forward<SentimentFilterT>(value));
    return *this;
  }
 private:
  NonTalkTimeFilter m_nonTalkTimeFilter;
 
  InterruptionFilter m_interruptionFilter;
 
  TranscriptFilter m_transcriptFilter;
 
  SentimentFilter m_sentimentFilter;
  bool m_nonTalkTimeFilterHasBeenSet = false;
  bool m_interruptionFilterHasBeenSet = false;
  bool m_transcriptFilterHasBeenSet = false;
  bool m_sentimentFilterHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace TranscribeService
}  // namespace Aws