GuardrailAutomatedReasoningFinding.h

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