Slot.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/lex-models/LexModelBuildingService_EXPORTS.h>
#include <aws/lex-models/model/ObfuscationSetting.h>
#include <aws/lex-models/model/Prompt.h>
#include <aws/lex-models/model/SlotConstraint.h>
#include <aws/lex-models/model/SlotDefaultValueSpec.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace LexModelBuildingService {
namespace Model {
 
class Slot {
 public:
  AWS_LEXMODELBUILDINGSERVICE_API Slot() = default;
  AWS_LEXMODELBUILDINGSERVICE_API Slot(Aws::Utils::Json::JsonView jsonValue);
  AWS_LEXMODELBUILDINGSERVICE_API Slot& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_LEXMODELBUILDINGSERVICE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetName() const { return m_name; }
  inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
  template <typename NameT = Aws::String>
  void SetName(NameT&& value) {
    m_nameHasBeenSet = true;
    m_name = std::forward<NameT>(value);
  }
  template <typename NameT = Aws::String>
  Slot& WithName(NameT&& value) {
    SetName(std::forward<NameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDescription() const { return m_description; }
  inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
  template <typename DescriptionT = Aws::String>
  void SetDescription(DescriptionT&& value) {
    m_descriptionHasBeenSet = true;
    m_description = std::forward<DescriptionT>(value);
  }
  template <typename DescriptionT = Aws::String>
  Slot& WithDescription(DescriptionT&& value) {
    SetDescription(std::forward<DescriptionT>(value));
    return *this;
  }
 
 
  inline SlotConstraint GetSlotConstraint() const { return m_slotConstraint; }
  inline bool SlotConstraintHasBeenSet() const { return m_slotConstraintHasBeenSet; }
  inline void SetSlotConstraint(SlotConstraint value) {
    m_slotConstraintHasBeenSet = true;
    m_slotConstraint = value;
  }
  inline Slot& WithSlotConstraint(SlotConstraint value) {
    SetSlotConstraint(value);
    return *this;
  }
 
 
  inline const Aws::String& GetSlotType() const { return m_slotType; }
  inline bool SlotTypeHasBeenSet() const { return m_slotTypeHasBeenSet; }
  template <typename SlotTypeT = Aws::String>
  void SetSlotType(SlotTypeT&& value) {
    m_slotTypeHasBeenSet = true;
    m_slotType = std::forward<SlotTypeT>(value);
  }
  template <typename SlotTypeT = Aws::String>
  Slot& WithSlotType(SlotTypeT&& value) {
    SetSlotType(std::forward<SlotTypeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSlotTypeVersion() const { return m_slotTypeVersion; }
  inline bool SlotTypeVersionHasBeenSet() const { return m_slotTypeVersionHasBeenSet; }
  template <typename SlotTypeVersionT = Aws::String>
  void SetSlotTypeVersion(SlotTypeVersionT&& value) {
    m_slotTypeVersionHasBeenSet = true;
    m_slotTypeVersion = std::forward<SlotTypeVersionT>(value);
  }
  template <typename SlotTypeVersionT = Aws::String>
  Slot& WithSlotTypeVersion(SlotTypeVersionT&& value) {
    SetSlotTypeVersion(std::forward<SlotTypeVersionT>(value));
    return *this;
  }
 
 
  inline const Prompt& GetValueElicitationPrompt() const { return m_valueElicitationPrompt; }
  inline bool ValueElicitationPromptHasBeenSet() const { return m_valueElicitationPromptHasBeenSet; }
  template <typename ValueElicitationPromptT = Prompt>
  void SetValueElicitationPrompt(ValueElicitationPromptT&& value) {
    m_valueElicitationPromptHasBeenSet = true;
    m_valueElicitationPrompt = std::forward<ValueElicitationPromptT>(value);
  }
  template <typename ValueElicitationPromptT = Prompt>
  Slot& WithValueElicitationPrompt(ValueElicitationPromptT&& value) {
    SetValueElicitationPrompt(std::forward<ValueElicitationPromptT>(value));
    return *this;
  }
 
 
  inline int GetPriority() const { return m_priority; }
  inline bool PriorityHasBeenSet() const { return m_priorityHasBeenSet; }
  inline void SetPriority(int value) {
    m_priorityHasBeenSet = true;
    m_priority = value;
  }
  inline Slot& WithPriority(int value) {
    SetPriority(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetSampleUtterances() const { return m_sampleUtterances; }
  inline bool SampleUtterancesHasBeenSet() const { return m_sampleUtterancesHasBeenSet; }
  template <typename SampleUtterancesT = Aws::Vector<Aws::String>>
  void SetSampleUtterances(SampleUtterancesT&& value) {
    m_sampleUtterancesHasBeenSet = true;
    m_sampleUtterances = std::forward<SampleUtterancesT>(value);
  }
  template <typename SampleUtterancesT = Aws::Vector<Aws::String>>
  Slot& WithSampleUtterances(SampleUtterancesT&& value) {
    SetSampleUtterances(std::forward<SampleUtterancesT>(value));
    return *this;
  }
  template <typename SampleUtterancesT = Aws::String>
  Slot& AddSampleUtterances(SampleUtterancesT&& value) {
    m_sampleUtterancesHasBeenSet = true;
    m_sampleUtterances.emplace_back(std::forward<SampleUtterancesT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetResponseCard() const { return m_responseCard; }
  inline bool ResponseCardHasBeenSet() const { return m_responseCardHasBeenSet; }
  template <typename ResponseCardT = Aws::String>
  void SetResponseCard(ResponseCardT&& value) {
    m_responseCardHasBeenSet = true;
    m_responseCard = std::forward<ResponseCardT>(value);
  }
  template <typename ResponseCardT = Aws::String>
  Slot& WithResponseCard(ResponseCardT&& value) {
    SetResponseCard(std::forward<ResponseCardT>(value));
    return *this;
  }
 
 
  inline ObfuscationSetting GetObfuscationSetting() const { return m_obfuscationSetting; }
  inline bool ObfuscationSettingHasBeenSet() const { return m_obfuscationSettingHasBeenSet; }
  inline void SetObfuscationSetting(ObfuscationSetting value) {
    m_obfuscationSettingHasBeenSet = true;
    m_obfuscationSetting = value;
  }
  inline Slot& WithObfuscationSetting(ObfuscationSetting value) {
    SetObfuscationSetting(value);
    return *this;
  }
 
 
  inline const SlotDefaultValueSpec& GetDefaultValueSpec() const { return m_defaultValueSpec; }
  inline bool DefaultValueSpecHasBeenSet() const { return m_defaultValueSpecHasBeenSet; }
  template <typename DefaultValueSpecT = SlotDefaultValueSpec>
  void SetDefaultValueSpec(DefaultValueSpecT&& value) {
    m_defaultValueSpecHasBeenSet = true;
    m_defaultValueSpec = std::forward<DefaultValueSpecT>(value);
  }
  template <typename DefaultValueSpecT = SlotDefaultValueSpec>
  Slot& WithDefaultValueSpec(DefaultValueSpecT&& value) {
    SetDefaultValueSpec(std::forward<DefaultValueSpecT>(value));
    return *this;
  }
 private:
  Aws::String m_name;
 
  Aws::String m_description;
 
  SlotConstraint m_slotConstraint{SlotConstraint::NOT_SET};
 
  Aws::String m_slotType;
 
  Aws::String m_slotTypeVersion;
 
  Prompt m_valueElicitationPrompt;
 
  int m_priority{0};
 
  Aws::Vector<Aws::String> m_sampleUtterances;
 
  Aws::String m_responseCard;
 
  ObfuscationSetting m_obfuscationSetting{ObfuscationSetting::NOT_SET};
 
  SlotDefaultValueSpec m_defaultValueSpec;
  bool m_nameHasBeenSet = false;
  bool m_descriptionHasBeenSet = false;
  bool m_slotConstraintHasBeenSet = false;
  bool m_slotTypeHasBeenSet = false;
  bool m_slotTypeVersionHasBeenSet = false;
  bool m_valueElicitationPromptHasBeenSet = false;
  bool m_priorityHasBeenSet = false;
  bool m_sampleUtterancesHasBeenSet = false;
  bool m_responseCardHasBeenSet = false;
  bool m_obfuscationSettingHasBeenSet = false;
  bool m_defaultValueSpecHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace LexModelBuildingService
}  // namespace Aws