Addon.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/eks/EKS_EXPORTS.h>
#include <aws/eks/model/AddonHealth.h>
#include <aws/eks/model/AddonNamespaceConfigResponse.h>
#include <aws/eks/model/AddonStatus.h>
#include <aws/eks/model/MarketplaceInformation.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace EKS {
namespace Model {
 
class Addon {
 public:
  AWS_EKS_API Addon() = default;
  AWS_EKS_API Addon(Aws::Utils::Json::JsonView jsonValue);
  AWS_EKS_API Addon& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_EKS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetAddonName() const { return m_addonName; }
  inline bool AddonNameHasBeenSet() const { return m_addonNameHasBeenSet; }
  template <typename AddonNameT = Aws::String>
  void SetAddonName(AddonNameT&& value) {
    m_addonNameHasBeenSet = true;
    m_addonName = std::forward<AddonNameT>(value);
  }
  template <typename AddonNameT = Aws::String>
  Addon& WithAddonName(AddonNameT&& value) {
    SetAddonName(std::forward<AddonNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetClusterName() const { return m_clusterName; }
  inline bool ClusterNameHasBeenSet() const { return m_clusterNameHasBeenSet; }
  template <typename ClusterNameT = Aws::String>
  void SetClusterName(ClusterNameT&& value) {
    m_clusterNameHasBeenSet = true;
    m_clusterName = std::forward<ClusterNameT>(value);
  }
  template <typename ClusterNameT = Aws::String>
  Addon& WithClusterName(ClusterNameT&& value) {
    SetClusterName(std::forward<ClusterNameT>(value));
    return *this;
  }
 
 
  inline AddonStatus GetStatus() const { return m_status; }
  inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
  inline void SetStatus(AddonStatus value) {
    m_statusHasBeenSet = true;
    m_status = value;
  }
  inline Addon& WithStatus(AddonStatus value) {
    SetStatus(value);
    return *this;
  }
 
 
  inline const Aws::String& GetAddonVersion() const { return m_addonVersion; }
  inline bool AddonVersionHasBeenSet() const { return m_addonVersionHasBeenSet; }
  template <typename AddonVersionT = Aws::String>
  void SetAddonVersion(AddonVersionT&& value) {
    m_addonVersionHasBeenSet = true;
    m_addonVersion = std::forward<AddonVersionT>(value);
  }
  template <typename AddonVersionT = Aws::String>
  Addon& WithAddonVersion(AddonVersionT&& value) {
    SetAddonVersion(std::forward<AddonVersionT>(value));
    return *this;
  }
 
 
  inline const AddonHealth& GetHealth() const { return m_health; }
  inline bool HealthHasBeenSet() const { return m_healthHasBeenSet; }
  template <typename HealthT = AddonHealth>
  void SetHealth(HealthT&& value) {
    m_healthHasBeenSet = true;
    m_health = std::forward<HealthT>(value);
  }
  template <typename HealthT = AddonHealth>
  Addon& WithHealth(HealthT&& value) {
    SetHealth(std::forward<HealthT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAddonArn() const { return m_addonArn; }
  inline bool AddonArnHasBeenSet() const { return m_addonArnHasBeenSet; }
  template <typename AddonArnT = Aws::String>
  void SetAddonArn(AddonArnT&& value) {
    m_addonArnHasBeenSet = true;
    m_addonArn = std::forward<AddonArnT>(value);
  }
  template <typename AddonArnT = Aws::String>
  Addon& WithAddonArn(AddonArnT&& value) {
    SetAddonArn(std::forward<AddonArnT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCreatedAt() const { return m_createdAt; }
  inline bool CreatedAtHasBeenSet() const { return m_createdAtHasBeenSet; }
  template <typename CreatedAtT = Aws::Utils::DateTime>
  void SetCreatedAt(CreatedAtT&& value) {
    m_createdAtHasBeenSet = true;
    m_createdAt = std::forward<CreatedAtT>(value);
  }
  template <typename CreatedAtT = Aws::Utils::DateTime>
  Addon& WithCreatedAt(CreatedAtT&& value) {
    SetCreatedAt(std::forward<CreatedAtT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetModifiedAt() const { return m_modifiedAt; }
  inline bool ModifiedAtHasBeenSet() const { return m_modifiedAtHasBeenSet; }
  template <typename ModifiedAtT = Aws::Utils::DateTime>
  void SetModifiedAt(ModifiedAtT&& value) {
    m_modifiedAtHasBeenSet = true;
    m_modifiedAt = std::forward<ModifiedAtT>(value);
  }
  template <typename ModifiedAtT = Aws::Utils::DateTime>
  Addon& WithModifiedAt(ModifiedAtT&& value) {
    SetModifiedAt(std::forward<ModifiedAtT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetServiceAccountRoleArn() const { return m_serviceAccountRoleArn; }
  inline bool ServiceAccountRoleArnHasBeenSet() const { return m_serviceAccountRoleArnHasBeenSet; }
  template <typename ServiceAccountRoleArnT = Aws::String>
  void SetServiceAccountRoleArn(ServiceAccountRoleArnT&& value) {
    m_serviceAccountRoleArnHasBeenSet = true;
    m_serviceAccountRoleArn = std::forward<ServiceAccountRoleArnT>(value);
  }
  template <typename ServiceAccountRoleArnT = Aws::String>
  Addon& WithServiceAccountRoleArn(ServiceAccountRoleArnT&& value) {
    SetServiceAccountRoleArn(std::forward<ServiceAccountRoleArnT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetTags() const { return m_tags; }
  inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
  template <typename TagsT = Aws::Map<Aws::String, Aws::String>>
  void SetTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags = std::forward<TagsT>(value);
  }
  template <typename TagsT = Aws::Map<Aws::String, Aws::String>>
  Addon& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsKeyT = Aws::String, typename TagsValueT = Aws::String>
  Addon& AddTags(TagsKeyT&& key, TagsValueT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace(std::forward<TagsKeyT>(key), std::forward<TagsValueT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPublisher() const { return m_publisher; }
  inline bool PublisherHasBeenSet() const { return m_publisherHasBeenSet; }
  template <typename PublisherT = Aws::String>
  void SetPublisher(PublisherT&& value) {
    m_publisherHasBeenSet = true;
    m_publisher = std::forward<PublisherT>(value);
  }
  template <typename PublisherT = Aws::String>
  Addon& WithPublisher(PublisherT&& value) {
    SetPublisher(std::forward<PublisherT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetOwner() const { return m_owner; }
  inline bool OwnerHasBeenSet() const { return m_ownerHasBeenSet; }
  template <typename OwnerT = Aws::String>
  void SetOwner(OwnerT&& value) {
    m_ownerHasBeenSet = true;
    m_owner = std::forward<OwnerT>(value);
  }
  template <typename OwnerT = Aws::String>
  Addon& WithOwner(OwnerT&& value) {
    SetOwner(std::forward<OwnerT>(value));
    return *this;
  }
 
 
  inline const MarketplaceInformation& GetMarketplaceInformation() const { return m_marketplaceInformation; }
  inline bool MarketplaceInformationHasBeenSet() const { return m_marketplaceInformationHasBeenSet; }
  template <typename MarketplaceInformationT = MarketplaceInformation>
  void SetMarketplaceInformation(MarketplaceInformationT&& value) {
    m_marketplaceInformationHasBeenSet = true;
    m_marketplaceInformation = std::forward<MarketplaceInformationT>(value);
  }
  template <typename MarketplaceInformationT = MarketplaceInformation>
  Addon& WithMarketplaceInformation(MarketplaceInformationT&& value) {
    SetMarketplaceInformation(std::forward<MarketplaceInformationT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetConfigurationValues() const { return m_configurationValues; }
  inline bool ConfigurationValuesHasBeenSet() const { return m_configurationValuesHasBeenSet; }
  template <typename ConfigurationValuesT = Aws::String>
  void SetConfigurationValues(ConfigurationValuesT&& value) {
    m_configurationValuesHasBeenSet = true;
    m_configurationValues = std::forward<ConfigurationValuesT>(value);
  }
  template <typename ConfigurationValuesT = Aws::String>
  Addon& WithConfigurationValues(ConfigurationValuesT&& value) {
    SetConfigurationValues(std::forward<ConfigurationValuesT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetPodIdentityAssociations() const { return m_podIdentityAssociations; }
  inline bool PodIdentityAssociationsHasBeenSet() const { return m_podIdentityAssociationsHasBeenSet; }
  template <typename PodIdentityAssociationsT = Aws::Vector<Aws::String>>
  void SetPodIdentityAssociations(PodIdentityAssociationsT&& value) {
    m_podIdentityAssociationsHasBeenSet = true;
    m_podIdentityAssociations = std::forward<PodIdentityAssociationsT>(value);
  }
  template <typename PodIdentityAssociationsT = Aws::Vector<Aws::String>>
  Addon& WithPodIdentityAssociations(PodIdentityAssociationsT&& value) {
    SetPodIdentityAssociations(std::forward<PodIdentityAssociationsT>(value));
    return *this;
  }
  template <typename PodIdentityAssociationsT = Aws::String>
  Addon& AddPodIdentityAssociations(PodIdentityAssociationsT&& value) {
    m_podIdentityAssociationsHasBeenSet = true;
    m_podIdentityAssociations.emplace_back(std::forward<PodIdentityAssociationsT>(value));
    return *this;
  }
 
 
  inline const AddonNamespaceConfigResponse& GetNamespaceConfig() const { return m_namespaceConfig; }
  inline bool NamespaceConfigHasBeenSet() const { return m_namespaceConfigHasBeenSet; }
  template <typename NamespaceConfigT = AddonNamespaceConfigResponse>
  void SetNamespaceConfig(NamespaceConfigT&& value) {
    m_namespaceConfigHasBeenSet = true;
    m_namespaceConfig = std::forward<NamespaceConfigT>(value);
  }
  template <typename NamespaceConfigT = AddonNamespaceConfigResponse>
  Addon& WithNamespaceConfig(NamespaceConfigT&& value) {
    SetNamespaceConfig(std::forward<NamespaceConfigT>(value));
    return *this;
  }
 private:
  Aws::String m_addonName;
 
  Aws::String m_clusterName;
 
  AddonStatus m_status{AddonStatus::NOT_SET};
 
  Aws::String m_addonVersion;
 
  AddonHealth m_health;
 
  Aws::String m_addonArn;
 
  Aws::Utils::DateTime m_createdAt{};
 
  Aws::Utils::DateTime m_modifiedAt{};
 
  Aws::String m_serviceAccountRoleArn;
 
  Aws::Map<Aws::String, Aws::String> m_tags;
 
  Aws::String m_publisher;
 
  Aws::String m_owner;
 
  MarketplaceInformation m_marketplaceInformation;
 
  Aws::String m_configurationValues;
 
  Aws::Vector<Aws::String> m_podIdentityAssociations;
 
  AddonNamespaceConfigResponse m_namespaceConfig;
  bool m_addonNameHasBeenSet = false;
  bool m_clusterNameHasBeenSet = false;
  bool m_statusHasBeenSet = false;
  bool m_addonVersionHasBeenSet = false;
  bool m_healthHasBeenSet = false;
  bool m_addonArnHasBeenSet = false;
  bool m_createdAtHasBeenSet = false;
  bool m_modifiedAtHasBeenSet = false;
  bool m_serviceAccountRoleArnHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_publisherHasBeenSet = false;
  bool m_ownerHasBeenSet = false;
  bool m_marketplaceInformationHasBeenSet = false;
  bool m_configurationValuesHasBeenSet = false;
  bool m_podIdentityAssociationsHasBeenSet = false;
  bool m_namespaceConfigHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace EKS
}  // namespace Aws