CertificateAuthority.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/eks/EKS_EXPORTS.h>
#include <aws/eks/model/CertificateAuthorityActivatedBy.h>
#include <aws/eks/model/CertificateAuthorityCreatedBy.h>
#include <aws/eks/model/CertificateAuthorityDistributionStatus.h>
#include <aws/eks/model/CertificateAuthorityScheduledEvents.h>
#include <aws/eks/model/CertificateAuthoritySigningStatus.h>
#include <aws/eks/model/CertificateAuthorityValidity.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace EKS {
namespace Model {
 
class CertificateAuthority {
 public:
  AWS_EKS_API CertificateAuthority() = default;
  AWS_EKS_API CertificateAuthority(Aws::Utils::Json::JsonView jsonValue);
  AWS_EKS_API CertificateAuthority& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_EKS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetId() const { return m_id; }
  inline bool IdHasBeenSet() const { return m_idHasBeenSet; }
  template <typename IdT = Aws::String>
  void SetId(IdT&& value) {
    m_idHasBeenSet = true;
    m_id = std::forward<IdT>(value);
  }
  template <typename IdT = Aws::String>
  CertificateAuthority& WithId(IdT&& value) {
    SetId(std::forward<IdT>(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>
  CertificateAuthority& WithCreatedAt(CreatedAtT&& value) {
    SetCreatedAt(std::forward<CreatedAtT>(value));
    return *this;
  }
 
 
  inline CertificateAuthorityCreatedBy GetCreatedBy() const { return m_createdBy; }
  inline bool CreatedByHasBeenSet() const { return m_createdByHasBeenSet; }
  inline void SetCreatedBy(CertificateAuthorityCreatedBy value) {
    m_createdByHasBeenSet = true;
    m_createdBy = value;
  }
  inline CertificateAuthority& WithCreatedBy(CertificateAuthorityCreatedBy value) {
    SetCreatedBy(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetActivatedAt() const { return m_activatedAt; }
  inline bool ActivatedAtHasBeenSet() const { return m_activatedAtHasBeenSet; }
  template <typename ActivatedAtT = Aws::Utils::DateTime>
  void SetActivatedAt(ActivatedAtT&& value) {
    m_activatedAtHasBeenSet = true;
    m_activatedAt = std::forward<ActivatedAtT>(value);
  }
  template <typename ActivatedAtT = Aws::Utils::DateTime>
  CertificateAuthority& WithActivatedAt(ActivatedAtT&& value) {
    SetActivatedAt(std::forward<ActivatedAtT>(value));
    return *this;
  }
 
 
  inline CertificateAuthorityActivatedBy GetActivatedBy() const { return m_activatedBy; }
  inline bool ActivatedByHasBeenSet() const { return m_activatedByHasBeenSet; }
  inline void SetActivatedBy(CertificateAuthorityActivatedBy value) {
    m_activatedByHasBeenSet = true;
    m_activatedBy = value;
  }
  inline CertificateAuthority& WithActivatedBy(CertificateAuthorityActivatedBy value) {
    SetActivatedBy(value);
    return *this;
  }
 
 
  inline CertificateAuthoritySigningStatus GetSigningStatus() const { return m_signingStatus; }
  inline bool SigningStatusHasBeenSet() const { return m_signingStatusHasBeenSet; }
  inline void SetSigningStatus(CertificateAuthoritySigningStatus value) {
    m_signingStatusHasBeenSet = true;
    m_signingStatus = value;
  }
  inline CertificateAuthority& WithSigningStatus(CertificateAuthoritySigningStatus value) {
    SetSigningStatus(value);
    return *this;
  }
 
 
  inline CertificateAuthorityDistributionStatus GetDistributionStatus() const { return m_distributionStatus; }
  inline bool DistributionStatusHasBeenSet() const { return m_distributionStatusHasBeenSet; }
  inline void SetDistributionStatus(CertificateAuthorityDistributionStatus value) {
    m_distributionStatusHasBeenSet = true;
    m_distributionStatus = value;
  }
  inline CertificateAuthority& WithDistributionStatus(CertificateAuthorityDistributionStatus value) {
    SetDistributionStatus(value);
    return *this;
  }
 
 
  inline const CertificateAuthorityValidity& GetValidity() const { return m_validity; }
  inline bool ValidityHasBeenSet() const { return m_validityHasBeenSet; }
  template <typename ValidityT = CertificateAuthorityValidity>
  void SetValidity(ValidityT&& value) {
    m_validityHasBeenSet = true;
    m_validity = std::forward<ValidityT>(value);
  }
  template <typename ValidityT = CertificateAuthorityValidity>
  CertificateAuthority& WithValidity(ValidityT&& value) {
    SetValidity(std::forward<ValidityT>(value));
    return *this;
  }
 
 
  inline const CertificateAuthorityScheduledEvents& GetScheduledEvents() const { return m_scheduledEvents; }
  inline bool ScheduledEventsHasBeenSet() const { return m_scheduledEventsHasBeenSet; }
  template <typename ScheduledEventsT = CertificateAuthorityScheduledEvents>
  void SetScheduledEvents(ScheduledEventsT&& value) {
    m_scheduledEventsHasBeenSet = true;
    m_scheduledEvents = std::forward<ScheduledEventsT>(value);
  }
  template <typename ScheduledEventsT = CertificateAuthorityScheduledEvents>
  CertificateAuthority& WithScheduledEvents(ScheduledEventsT&& value) {
    SetScheduledEvents(std::forward<ScheduledEventsT>(value));
    return *this;
  }
 
 
  inline bool GetRollbackAvailable() const { return m_rollbackAvailable; }
  inline bool RollbackAvailableHasBeenSet() const { return m_rollbackAvailableHasBeenSet; }
  inline void SetRollbackAvailable(bool value) {
    m_rollbackAvailableHasBeenSet = true;
    m_rollbackAvailable = value;
  }
  inline CertificateAuthority& WithRollbackAvailable(bool value) {
    SetRollbackAvailable(value);
    return *this;
  }
 
 
  inline const Aws::String& GetData() const { return m_data; }
  inline bool DataHasBeenSet() const { return m_dataHasBeenSet; }
  template <typename DataT = Aws::String>
  void SetData(DataT&& value) {
    m_dataHasBeenSet = true;
    m_data = std::forward<DataT>(value);
  }
  template <typename DataT = Aws::String>
  CertificateAuthority& WithData(DataT&& value) {
    SetData(std::forward<DataT>(value));
    return *this;
  }
 private:
  Aws::String m_id;
 
  Aws::Utils::DateTime m_createdAt{};
 
  CertificateAuthorityCreatedBy m_createdBy{CertificateAuthorityCreatedBy::NOT_SET};
 
  Aws::Utils::DateTime m_activatedAt{};
 
  CertificateAuthorityActivatedBy m_activatedBy{CertificateAuthorityActivatedBy::NOT_SET};
 
  CertificateAuthoritySigningStatus m_signingStatus{CertificateAuthoritySigningStatus::NOT_SET};
 
  CertificateAuthorityDistributionStatus m_distributionStatus{CertificateAuthorityDistributionStatus::NOT_SET};
 
  CertificateAuthorityValidity m_validity;
 
  CertificateAuthorityScheduledEvents m_scheduledEvents;
 
  bool m_rollbackAvailable{false};
 
  Aws::String m_data;
  bool m_idHasBeenSet = false;
  bool m_createdAtHasBeenSet = false;
  bool m_createdByHasBeenSet = false;
  bool m_activatedAtHasBeenSet = false;
  bool m_activatedByHasBeenSet = false;
  bool m_signingStatusHasBeenSet = false;
  bool m_distributionStatusHasBeenSet = false;
  bool m_validityHasBeenSet = false;
  bool m_scheduledEventsHasBeenSet = false;
  bool m_rollbackAvailableHasBeenSet = false;
  bool m_dataHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace EKS
}  // namespace Aws