CategoryProperties.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/transcribe/TranscribeService_EXPORTS.h>
#include <aws/transcribe/model/InputType.h>
#include <aws/transcribe/model/Rule.h>
#include <aws/transcribe/model/Tag.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace TranscribeService {
namespace Model {
 
class CategoryProperties {
 public:
  AWS_TRANSCRIBESERVICE_API CategoryProperties() = default;
  AWS_TRANSCRIBESERVICE_API CategoryProperties(Aws::Utils::Json::JsonView jsonValue);
  AWS_TRANSCRIBESERVICE_API CategoryProperties& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_TRANSCRIBESERVICE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetCategoryName() const { return m_categoryName; }
  inline bool CategoryNameHasBeenSet() const { return m_categoryNameHasBeenSet; }
  template <typename CategoryNameT = Aws::String>
  void SetCategoryName(CategoryNameT&& value) {
    m_categoryNameHasBeenSet = true;
    m_categoryName = std::forward<CategoryNameT>(value);
  }
  template <typename CategoryNameT = Aws::String>
  CategoryProperties& WithCategoryName(CategoryNameT&& value) {
    SetCategoryName(std::forward<CategoryNameT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Rule>& GetRules() const { return m_rules; }
  inline bool RulesHasBeenSet() const { return m_rulesHasBeenSet; }
  template <typename RulesT = Aws::Vector<Rule>>
  void SetRules(RulesT&& value) {
    m_rulesHasBeenSet = true;
    m_rules = std::forward<RulesT>(value);
  }
  template <typename RulesT = Aws::Vector<Rule>>
  CategoryProperties& WithRules(RulesT&& value) {
    SetRules(std::forward<RulesT>(value));
    return *this;
  }
  template <typename RulesT = Rule>
  CategoryProperties& AddRules(RulesT&& value) {
    m_rulesHasBeenSet = true;
    m_rules.emplace_back(std::forward<RulesT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCreateTime() const { return m_createTime; }
  inline bool CreateTimeHasBeenSet() const { return m_createTimeHasBeenSet; }
  template <typename CreateTimeT = Aws::Utils::DateTime>
  void SetCreateTime(CreateTimeT&& value) {
    m_createTimeHasBeenSet = true;
    m_createTime = std::forward<CreateTimeT>(value);
  }
  template <typename CreateTimeT = Aws::Utils::DateTime>
  CategoryProperties& WithCreateTime(CreateTimeT&& value) {
    SetCreateTime(std::forward<CreateTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetLastUpdateTime() const { return m_lastUpdateTime; }
  inline bool LastUpdateTimeHasBeenSet() const { return m_lastUpdateTimeHasBeenSet; }
  template <typename LastUpdateTimeT = Aws::Utils::DateTime>
  void SetLastUpdateTime(LastUpdateTimeT&& value) {
    m_lastUpdateTimeHasBeenSet = true;
    m_lastUpdateTime = std::forward<LastUpdateTimeT>(value);
  }
  template <typename LastUpdateTimeT = Aws::Utils::DateTime>
  CategoryProperties& WithLastUpdateTime(LastUpdateTimeT&& value) {
    SetLastUpdateTime(std::forward<LastUpdateTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Tag>& GetTags() const { return m_tags; }
  inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
  template <typename TagsT = Aws::Vector<Tag>>
  void SetTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags = std::forward<TagsT>(value);
  }
  template <typename TagsT = Aws::Vector<Tag>>
  CategoryProperties& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsT = Tag>
  CategoryProperties& AddTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace_back(std::forward<TagsT>(value));
    return *this;
  }
 
 
  inline InputType GetInputType() const { return m_inputType; }
  inline bool InputTypeHasBeenSet() const { return m_inputTypeHasBeenSet; }
  inline void SetInputType(InputType value) {
    m_inputTypeHasBeenSet = true;
    m_inputType = value;
  }
  inline CategoryProperties& WithInputType(InputType value) {
    SetInputType(value);
    return *this;
  }
 private:
  Aws::String m_categoryName;
 
  Aws::Vector<Rule> m_rules;
 
  Aws::Utils::DateTime m_createTime{};
 
  Aws::Utils::DateTime m_lastUpdateTime{};
 
  Aws::Vector<Tag> m_tags;
 
  InputType m_inputType{InputType::NOT_SET};
  bool m_categoryNameHasBeenSet = false;
  bool m_rulesHasBeenSet = false;
  bool m_createTimeHasBeenSet = false;
  bool m_lastUpdateTimeHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_inputTypeHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace TranscribeService
}  // namespace Aws