AutomatedReasoningCheckFinding.h

 
#pragma once
#include <aws/bedrock/Bedrock_EXPORTS.h>
#include <aws/bedrock/model/AutomatedReasoningCheckImpossibleFinding.h>
#include <aws/bedrock/model/AutomatedReasoningCheckInvalidFinding.h>
#include <aws/bedrock/model/AutomatedReasoningCheckNoTranslationsFinding.h>
#include <aws/bedrock/model/AutomatedReasoningCheckSatisfiableFinding.h>
#include <aws/bedrock/model/AutomatedReasoningCheckTooComplexFinding.h>
#include <aws/bedrock/model/AutomatedReasoningCheckTranslationAmbiguousFinding.h>
#include <aws/bedrock/model/AutomatedReasoningCheckValidFinding.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Bedrock {
namespace Model {
 
class AutomatedReasoningCheckFinding {
 public:
  AWS_BEDROCK_API AutomatedReasoningCheckFinding() = default;
  AWS_BEDROCK_API AutomatedReasoningCheckFinding(Aws::Utils::Json::JsonView jsonValue);
  AWS_BEDROCK_API AutomatedReasoningCheckFinding& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_BEDROCK_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const AutomatedReasoningCheckValidFinding& GetValid() const { return m_valid; }
  inline bool ValidHasBeenSet() const { return m_validHasBeenSet; }
  template <typename ValidT = AutomatedReasoningCheckValidFinding>
  void SetValid(ValidT&& value) {
    m_validHasBeenSet = true;
    m_valid = std::forward<ValidT>(value);
  }
  template <typename ValidT = AutomatedReasoningCheckValidFinding>
  AutomatedReasoningCheckFinding& WithValid(ValidT&& value) {
    SetValid(std::forward<ValidT>(value));
    return *this;
  }
 
 
  inline const AutomatedReasoningCheckInvalidFinding& GetInvalid() const { return m_invalid; }
  inline bool InvalidHasBeenSet() const { return m_invalidHasBeenSet; }
  template <typename InvalidT = AutomatedReasoningCheckInvalidFinding>
  void SetInvalid(InvalidT&& value) {
    m_invalidHasBeenSet = true;
    m_invalid = std::forward<InvalidT>(value);
  }
  template <typename InvalidT = AutomatedReasoningCheckInvalidFinding>
  AutomatedReasoningCheckFinding& WithInvalid(InvalidT&& value) {
    SetInvalid(std::forward<InvalidT>(value));
    return *this;
  }
 
 
  inline const AutomatedReasoningCheckSatisfiableFinding& GetSatisfiable() const { return m_satisfiable; }
  inline bool SatisfiableHasBeenSet() const { return m_satisfiableHasBeenSet; }
  template <typename SatisfiableT = AutomatedReasoningCheckSatisfiableFinding>
  void SetSatisfiable(SatisfiableT&& value) {
    m_satisfiableHasBeenSet = true;
    m_satisfiable = std::forward<SatisfiableT>(value);
  }
  template <typename SatisfiableT = AutomatedReasoningCheckSatisfiableFinding>
  AutomatedReasoningCheckFinding& WithSatisfiable(SatisfiableT&& value) {
    SetSatisfiable(std::forward<SatisfiableT>(value));
    return *this;
  }
 
 
  inline const AutomatedReasoningCheckImpossibleFinding& GetImpossible() const { return m_impossible; }
  inline bool ImpossibleHasBeenSet() const { return m_impossibleHasBeenSet; }
  template <typename ImpossibleT = AutomatedReasoningCheckImpossibleFinding>
  void SetImpossible(ImpossibleT&& value) {
    m_impossibleHasBeenSet = true;
    m_impossible = std::forward<ImpossibleT>(value);
  }
  template <typename ImpossibleT = AutomatedReasoningCheckImpossibleFinding>
  AutomatedReasoningCheckFinding& WithImpossible(ImpossibleT&& value) {
    SetImpossible(std::forward<ImpossibleT>(value));
    return *this;
  }
 
 
  inline const AutomatedReasoningCheckTranslationAmbiguousFinding& GetTranslationAmbiguous() const { return m_translationAmbiguous; }
  inline bool TranslationAmbiguousHasBeenSet() const { return m_translationAmbiguousHasBeenSet; }
  template <typename TranslationAmbiguousT = AutomatedReasoningCheckTranslationAmbiguousFinding>
  void SetTranslationAmbiguous(TranslationAmbiguousT&& value) {
    m_translationAmbiguousHasBeenSet = true;
    m_translationAmbiguous = std::forward<TranslationAmbiguousT>(value);
  }
  template <typename TranslationAmbiguousT = AutomatedReasoningCheckTranslationAmbiguousFinding>
  AutomatedReasoningCheckFinding& WithTranslationAmbiguous(TranslationAmbiguousT&& value) {
    SetTranslationAmbiguous(std::forward<TranslationAmbiguousT>(value));
    return *this;
  }
 
 
  inline const AutomatedReasoningCheckTooComplexFinding& GetTooComplex() const { return m_tooComplex; }
  inline bool TooComplexHasBeenSet() const { return m_tooComplexHasBeenSet; }
  template <typename TooComplexT = AutomatedReasoningCheckTooComplexFinding>
  void SetTooComplex(TooComplexT&& value) {
    m_tooComplexHasBeenSet = true;
    m_tooComplex = std::forward<TooComplexT>(value);
  }
  template <typename TooComplexT = AutomatedReasoningCheckTooComplexFinding>
  AutomatedReasoningCheckFinding& WithTooComplex(TooComplexT&& value) {
    SetTooComplex(std::forward<TooComplexT>(value));
    return *this;
  }
 
 
  inline const AutomatedReasoningCheckNoTranslationsFinding& GetNoTranslations() const { return m_noTranslations; }
  inline bool NoTranslationsHasBeenSet() const { return m_noTranslationsHasBeenSet; }
  template <typename NoTranslationsT = AutomatedReasoningCheckNoTranslationsFinding>
  void SetNoTranslations(NoTranslationsT&& value) {
    m_noTranslationsHasBeenSet = true;
    m_noTranslations = std::forward<NoTranslationsT>(value);
  }
  template <typename NoTranslationsT = AutomatedReasoningCheckNoTranslationsFinding>
  AutomatedReasoningCheckFinding& WithNoTranslations(NoTranslationsT&& value) {
    SetNoTranslations(std::forward<NoTranslationsT>(value));
    return *this;
  }
 private:
  AutomatedReasoningCheckValidFinding m_valid;
 
  AutomatedReasoningCheckInvalidFinding m_invalid;
 
  AutomatedReasoningCheckSatisfiableFinding m_satisfiable;
 
  AutomatedReasoningCheckImpossibleFinding m_impossible;
 
  AutomatedReasoningCheckTranslationAmbiguousFinding m_translationAmbiguous;
 
  AutomatedReasoningCheckTooComplexFinding m_tooComplex;
 
  AutomatedReasoningCheckNoTranslationsFinding m_noTranslations;
  bool m_validHasBeenSet = false;
  bool m_invalidHasBeenSet = false;
  bool m_satisfiableHasBeenSet = false;
  bool m_impossibleHasBeenSet = false;
  bool m_translationAmbiguousHasBeenSet = false;
  bool m_tooComplexHasBeenSet = false;
  bool m_noTranslationsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Bedrock
}  // namespace Aws