Cluster.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/AccessConfigResponse.h>
#include <aws/eks/model/Certificate.h>
#include <aws/eks/model/ClusterHealth.h>
#include <aws/eks/model/ClusterStatus.h>
#include <aws/eks/model/ComputeConfigResponse.h>
#include <aws/eks/model/ConnectorConfigResponse.h>
#include <aws/eks/model/ControlPlaneScalingConfig.h>
#include <aws/eks/model/EncryptionConfig.h>
#include <aws/eks/model/Identity.h>
#include <aws/eks/model/KubeApiServerConfigResponse.h>
#include <aws/eks/model/KubeControllerManagerConfigResponse.h>
#include <aws/eks/model/KubeSchedulerConfigResponse.h>
#include <aws/eks/model/KubernetesNetworkConfigResponse.h>
#include <aws/eks/model/Logging.h>
#include <aws/eks/model/OutpostConfigResponse.h>
#include <aws/eks/model/RemoteNetworkConfigResponse.h>
#include <aws/eks/model/StorageConfigResponse.h>
#include <aws/eks/model/UpgradePolicyResponse.h>
#include <aws/eks/model/VpcConfigResponse.h>
#include <aws/eks/model/ZonalShiftConfigResponse.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace EKS {
namespace Model {
 
class Cluster {
 public:
  AWS_EKS_API Cluster() = default;
  AWS_EKS_API Cluster(Aws::Utils::Json::JsonView jsonValue);
  AWS_EKS_API Cluster& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_EKS_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>
  Cluster& WithName(NameT&& value) {
    SetName(std::forward<NameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetArn() const { return m_arn; }
  inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
  template <typename ArnT = Aws::String>
  void SetArn(ArnT&& value) {
    m_arnHasBeenSet = true;
    m_arn = std::forward<ArnT>(value);
  }
  template <typename ArnT = Aws::String>
  Cluster& WithArn(ArnT&& value) {
    SetArn(std::forward<ArnT>(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>
  Cluster& WithCreatedAt(CreatedAtT&& value) {
    SetCreatedAt(std::forward<CreatedAtT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetVersion() const { return m_version; }
  inline bool VersionHasBeenSet() const { return m_versionHasBeenSet; }
  template <typename VersionT = Aws::String>
  void SetVersion(VersionT&& value) {
    m_versionHasBeenSet = true;
    m_version = std::forward<VersionT>(value);
  }
  template <typename VersionT = Aws::String>
  Cluster& WithVersion(VersionT&& value) {
    SetVersion(std::forward<VersionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetEndpoint() const { return m_endpoint; }
  inline bool EndpointHasBeenSet() const { return m_endpointHasBeenSet; }
  template <typename EndpointT = Aws::String>
  void SetEndpoint(EndpointT&& value) {
    m_endpointHasBeenSet = true;
    m_endpoint = std::forward<EndpointT>(value);
  }
  template <typename EndpointT = Aws::String>
  Cluster& WithEndpoint(EndpointT&& value) {
    SetEndpoint(std::forward<EndpointT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRoleArn() const { return m_roleArn; }
  inline bool RoleArnHasBeenSet() const { return m_roleArnHasBeenSet; }
  template <typename RoleArnT = Aws::String>
  void SetRoleArn(RoleArnT&& value) {
    m_roleArnHasBeenSet = true;
    m_roleArn = std::forward<RoleArnT>(value);
  }
  template <typename RoleArnT = Aws::String>
  Cluster& WithRoleArn(RoleArnT&& value) {
    SetRoleArn(std::forward<RoleArnT>(value));
    return *this;
  }
 
 
  inline const VpcConfigResponse& GetResourcesVpcConfig() const { return m_resourcesVpcConfig; }
  inline bool ResourcesVpcConfigHasBeenSet() const { return m_resourcesVpcConfigHasBeenSet; }
  template <typename ResourcesVpcConfigT = VpcConfigResponse>
  void SetResourcesVpcConfig(ResourcesVpcConfigT&& value) {
    m_resourcesVpcConfigHasBeenSet = true;
    m_resourcesVpcConfig = std::forward<ResourcesVpcConfigT>(value);
  }
  template <typename ResourcesVpcConfigT = VpcConfigResponse>
  Cluster& WithResourcesVpcConfig(ResourcesVpcConfigT&& value) {
    SetResourcesVpcConfig(std::forward<ResourcesVpcConfigT>(value));
    return *this;
  }
 
 
  inline const KubernetesNetworkConfigResponse& GetKubernetesNetworkConfig() const { return m_kubernetesNetworkConfig; }
  inline bool KubernetesNetworkConfigHasBeenSet() const { return m_kubernetesNetworkConfigHasBeenSet; }
  template <typename KubernetesNetworkConfigT = KubernetesNetworkConfigResponse>
  void SetKubernetesNetworkConfig(KubernetesNetworkConfigT&& value) {
    m_kubernetesNetworkConfigHasBeenSet = true;
    m_kubernetesNetworkConfig = std::forward<KubernetesNetworkConfigT>(value);
  }
  template <typename KubernetesNetworkConfigT = KubernetesNetworkConfigResponse>
  Cluster& WithKubernetesNetworkConfig(KubernetesNetworkConfigT&& value) {
    SetKubernetesNetworkConfig(std::forward<KubernetesNetworkConfigT>(value));
    return *this;
  }
 
 
  inline const Logging& GetLogging() const { return m_logging; }
  inline bool LoggingHasBeenSet() const { return m_loggingHasBeenSet; }
  template <typename LoggingT = Logging>
  void SetLogging(LoggingT&& value) {
    m_loggingHasBeenSet = true;
    m_logging = std::forward<LoggingT>(value);
  }
  template <typename LoggingT = Logging>
  Cluster& WithLogging(LoggingT&& value) {
    SetLogging(std::forward<LoggingT>(value));
    return *this;
  }
 
 
  inline const Identity& GetIdentity() const { return m_identity; }
  inline bool IdentityHasBeenSet() const { return m_identityHasBeenSet; }
  template <typename IdentityT = Identity>
  void SetIdentity(IdentityT&& value) {
    m_identityHasBeenSet = true;
    m_identity = std::forward<IdentityT>(value);
  }
  template <typename IdentityT = Identity>
  Cluster& WithIdentity(IdentityT&& value) {
    SetIdentity(std::forward<IdentityT>(value));
    return *this;
  }
 
 
  inline ClusterStatus GetStatus() const { return m_status; }
  inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
  inline void SetStatus(ClusterStatus value) {
    m_statusHasBeenSet = true;
    m_status = value;
  }
  inline Cluster& WithStatus(ClusterStatus value) {
    SetStatus(value);
    return *this;
  }
 
 
  inline const Certificate& GetCertificateAuthority() const { return m_certificateAuthority; }
  inline bool CertificateAuthorityHasBeenSet() const { return m_certificateAuthorityHasBeenSet; }
  template <typename CertificateAuthorityT = Certificate>
  void SetCertificateAuthority(CertificateAuthorityT&& value) {
    m_certificateAuthorityHasBeenSet = true;
    m_certificateAuthority = std::forward<CertificateAuthorityT>(value);
  }
  template <typename CertificateAuthorityT = Certificate>
  Cluster& WithCertificateAuthority(CertificateAuthorityT&& value) {
    SetCertificateAuthority(std::forward<CertificateAuthorityT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetClientRequestToken() const { return m_clientRequestToken; }
  inline bool ClientRequestTokenHasBeenSet() const { return m_clientRequestTokenHasBeenSet; }
  template <typename ClientRequestTokenT = Aws::String>
  void SetClientRequestToken(ClientRequestTokenT&& value) {
    m_clientRequestTokenHasBeenSet = true;
    m_clientRequestToken = std::forward<ClientRequestTokenT>(value);
  }
  template <typename ClientRequestTokenT = Aws::String>
  Cluster& WithClientRequestToken(ClientRequestTokenT&& value) {
    SetClientRequestToken(std::forward<ClientRequestTokenT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPlatformVersion() const { return m_platformVersion; }
  inline bool PlatformVersionHasBeenSet() const { return m_platformVersionHasBeenSet; }
  template <typename PlatformVersionT = Aws::String>
  void SetPlatformVersion(PlatformVersionT&& value) {
    m_platformVersionHasBeenSet = true;
    m_platformVersion = std::forward<PlatformVersionT>(value);
  }
  template <typename PlatformVersionT = Aws::String>
  Cluster& WithPlatformVersion(PlatformVersionT&& value) {
    SetPlatformVersion(std::forward<PlatformVersionT>(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>>
  Cluster& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsKeyT = Aws::String, typename TagsValueT = Aws::String>
  Cluster& AddTags(TagsKeyT&& key, TagsValueT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace(std::forward<TagsKeyT>(key), std::forward<TagsValueT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<EncryptionConfig>& GetEncryptionConfig() const { return m_encryptionConfig; }
  inline bool EncryptionConfigHasBeenSet() const { return m_encryptionConfigHasBeenSet; }
  template <typename EncryptionConfigT = Aws::Vector<EncryptionConfig>>
  void SetEncryptionConfig(EncryptionConfigT&& value) {
    m_encryptionConfigHasBeenSet = true;
    m_encryptionConfig = std::forward<EncryptionConfigT>(value);
  }
  template <typename EncryptionConfigT = Aws::Vector<EncryptionConfig>>
  Cluster& WithEncryptionConfig(EncryptionConfigT&& value) {
    SetEncryptionConfig(std::forward<EncryptionConfigT>(value));
    return *this;
  }
  template <typename EncryptionConfigT = EncryptionConfig>
  Cluster& AddEncryptionConfig(EncryptionConfigT&& value) {
    m_encryptionConfigHasBeenSet = true;
    m_encryptionConfig.emplace_back(std::forward<EncryptionConfigT>(value));
    return *this;
  }
 
 
  inline const ConnectorConfigResponse& GetConnectorConfig() const { return m_connectorConfig; }
  inline bool ConnectorConfigHasBeenSet() const { return m_connectorConfigHasBeenSet; }
  template <typename ConnectorConfigT = ConnectorConfigResponse>
  void SetConnectorConfig(ConnectorConfigT&& value) {
    m_connectorConfigHasBeenSet = true;
    m_connectorConfig = std::forward<ConnectorConfigT>(value);
  }
  template <typename ConnectorConfigT = ConnectorConfigResponse>
  Cluster& WithConnectorConfig(ConnectorConfigT&& value) {
    SetConnectorConfig(std::forward<ConnectorConfigT>(value));
    return *this;
  }
 
 
  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>
  Cluster& WithId(IdT&& value) {
    SetId(std::forward<IdT>(value));
    return *this;
  }
 
 
  inline const ClusterHealth& GetHealth() const { return m_health; }
  inline bool HealthHasBeenSet() const { return m_healthHasBeenSet; }
  template <typename HealthT = ClusterHealth>
  void SetHealth(HealthT&& value) {
    m_healthHasBeenSet = true;
    m_health = std::forward<HealthT>(value);
  }
  template <typename HealthT = ClusterHealth>
  Cluster& WithHealth(HealthT&& value) {
    SetHealth(std::forward<HealthT>(value));
    return *this;
  }
 
 
  inline const OutpostConfigResponse& GetOutpostConfig() const { return m_outpostConfig; }
  inline bool OutpostConfigHasBeenSet() const { return m_outpostConfigHasBeenSet; }
  template <typename OutpostConfigT = OutpostConfigResponse>
  void SetOutpostConfig(OutpostConfigT&& value) {
    m_outpostConfigHasBeenSet = true;
    m_outpostConfig = std::forward<OutpostConfigT>(value);
  }
  template <typename OutpostConfigT = OutpostConfigResponse>
  Cluster& WithOutpostConfig(OutpostConfigT&& value) {
    SetOutpostConfig(std::forward<OutpostConfigT>(value));
    return *this;
  }
 
 
  inline const AccessConfigResponse& GetAccessConfig() const { return m_accessConfig; }
  inline bool AccessConfigHasBeenSet() const { return m_accessConfigHasBeenSet; }
  template <typename AccessConfigT = AccessConfigResponse>
  void SetAccessConfig(AccessConfigT&& value) {
    m_accessConfigHasBeenSet = true;
    m_accessConfig = std::forward<AccessConfigT>(value);
  }
  template <typename AccessConfigT = AccessConfigResponse>
  Cluster& WithAccessConfig(AccessConfigT&& value) {
    SetAccessConfig(std::forward<AccessConfigT>(value));
    return *this;
  }
 
 
  inline const UpgradePolicyResponse& GetUpgradePolicy() const { return m_upgradePolicy; }
  inline bool UpgradePolicyHasBeenSet() const { return m_upgradePolicyHasBeenSet; }
  template <typename UpgradePolicyT = UpgradePolicyResponse>
  void SetUpgradePolicy(UpgradePolicyT&& value) {
    m_upgradePolicyHasBeenSet = true;
    m_upgradePolicy = std::forward<UpgradePolicyT>(value);
  }
  template <typename UpgradePolicyT = UpgradePolicyResponse>
  Cluster& WithUpgradePolicy(UpgradePolicyT&& value) {
    SetUpgradePolicy(std::forward<UpgradePolicyT>(value));
    return *this;
  }
 
 
  inline const ZonalShiftConfigResponse& GetZonalShiftConfig() const { return m_zonalShiftConfig; }
  inline bool ZonalShiftConfigHasBeenSet() const { return m_zonalShiftConfigHasBeenSet; }
  template <typename ZonalShiftConfigT = ZonalShiftConfigResponse>
  void SetZonalShiftConfig(ZonalShiftConfigT&& value) {
    m_zonalShiftConfigHasBeenSet = true;
    m_zonalShiftConfig = std::forward<ZonalShiftConfigT>(value);
  }
  template <typename ZonalShiftConfigT = ZonalShiftConfigResponse>
  Cluster& WithZonalShiftConfig(ZonalShiftConfigT&& value) {
    SetZonalShiftConfig(std::forward<ZonalShiftConfigT>(value));
    return *this;
  }
 
 
  inline const RemoteNetworkConfigResponse& GetRemoteNetworkConfig() const { return m_remoteNetworkConfig; }
  inline bool RemoteNetworkConfigHasBeenSet() const { return m_remoteNetworkConfigHasBeenSet; }
  template <typename RemoteNetworkConfigT = RemoteNetworkConfigResponse>
  void SetRemoteNetworkConfig(RemoteNetworkConfigT&& value) {
    m_remoteNetworkConfigHasBeenSet = true;
    m_remoteNetworkConfig = std::forward<RemoteNetworkConfigT>(value);
  }
  template <typename RemoteNetworkConfigT = RemoteNetworkConfigResponse>
  Cluster& WithRemoteNetworkConfig(RemoteNetworkConfigT&& value) {
    SetRemoteNetworkConfig(std::forward<RemoteNetworkConfigT>(value));
    return *this;
  }
 
 
  inline const ComputeConfigResponse& GetComputeConfig() const { return m_computeConfig; }
  inline bool ComputeConfigHasBeenSet() const { return m_computeConfigHasBeenSet; }
  template <typename ComputeConfigT = ComputeConfigResponse>
  void SetComputeConfig(ComputeConfigT&& value) {
    m_computeConfigHasBeenSet = true;
    m_computeConfig = std::forward<ComputeConfigT>(value);
  }
  template <typename ComputeConfigT = ComputeConfigResponse>
  Cluster& WithComputeConfig(ComputeConfigT&& value) {
    SetComputeConfig(std::forward<ComputeConfigT>(value));
    return *this;
  }
 
 
  inline const StorageConfigResponse& GetStorageConfig() const { return m_storageConfig; }
  inline bool StorageConfigHasBeenSet() const { return m_storageConfigHasBeenSet; }
  template <typename StorageConfigT = StorageConfigResponse>
  void SetStorageConfig(StorageConfigT&& value) {
    m_storageConfigHasBeenSet = true;
    m_storageConfig = std::forward<StorageConfigT>(value);
  }
  template <typename StorageConfigT = StorageConfigResponse>
  Cluster& WithStorageConfig(StorageConfigT&& value) {
    SetStorageConfig(std::forward<StorageConfigT>(value));
    return *this;
  }
 
 
  inline bool GetDeletionProtection() const { return m_deletionProtection; }
  inline bool DeletionProtectionHasBeenSet() const { return m_deletionProtectionHasBeenSet; }
  inline void SetDeletionProtection(bool value) {
    m_deletionProtectionHasBeenSet = true;
    m_deletionProtection = value;
  }
  inline Cluster& WithDeletionProtection(bool value) {
    SetDeletionProtection(value);
    return *this;
  }
 
 
  inline const ControlPlaneScalingConfig& GetControlPlaneScalingConfig() const { return m_controlPlaneScalingConfig; }
  inline bool ControlPlaneScalingConfigHasBeenSet() const { return m_controlPlaneScalingConfigHasBeenSet; }
  template <typename ControlPlaneScalingConfigT = ControlPlaneScalingConfig>
  void SetControlPlaneScalingConfig(ControlPlaneScalingConfigT&& value) {
    m_controlPlaneScalingConfigHasBeenSet = true;
    m_controlPlaneScalingConfig = std::forward<ControlPlaneScalingConfigT>(value);
  }
  template <typename ControlPlaneScalingConfigT = ControlPlaneScalingConfig>
  Cluster& WithControlPlaneScalingConfig(ControlPlaneScalingConfigT&& value) {
    SetControlPlaneScalingConfig(std::forward<ControlPlaneScalingConfigT>(value));
    return *this;
  }
 
 
  inline const KubeApiServerConfigResponse& GetKubeApiServerConfig() const { return m_kubeApiServerConfig; }
  inline bool KubeApiServerConfigHasBeenSet() const { return m_kubeApiServerConfigHasBeenSet; }
  template <typename KubeApiServerConfigT = KubeApiServerConfigResponse>
  void SetKubeApiServerConfig(KubeApiServerConfigT&& value) {
    m_kubeApiServerConfigHasBeenSet = true;
    m_kubeApiServerConfig = std::forward<KubeApiServerConfigT>(value);
  }
  template <typename KubeApiServerConfigT = KubeApiServerConfigResponse>
  Cluster& WithKubeApiServerConfig(KubeApiServerConfigT&& value) {
    SetKubeApiServerConfig(std::forward<KubeApiServerConfigT>(value));
    return *this;
  }
 
 
  inline const KubeSchedulerConfigResponse& GetKubeSchedulerConfig() const { return m_kubeSchedulerConfig; }
  inline bool KubeSchedulerConfigHasBeenSet() const { return m_kubeSchedulerConfigHasBeenSet; }
  template <typename KubeSchedulerConfigT = KubeSchedulerConfigResponse>
  void SetKubeSchedulerConfig(KubeSchedulerConfigT&& value) {
    m_kubeSchedulerConfigHasBeenSet = true;
    m_kubeSchedulerConfig = std::forward<KubeSchedulerConfigT>(value);
  }
  template <typename KubeSchedulerConfigT = KubeSchedulerConfigResponse>
  Cluster& WithKubeSchedulerConfig(KubeSchedulerConfigT&& value) {
    SetKubeSchedulerConfig(std::forward<KubeSchedulerConfigT>(value));
    return *this;
  }
 
 
  inline const KubeControllerManagerConfigResponse& GetKubeControllerManagerConfig() const { return m_kubeControllerManagerConfig; }
  inline bool KubeControllerManagerConfigHasBeenSet() const { return m_kubeControllerManagerConfigHasBeenSet; }
  template <typename KubeControllerManagerConfigT = KubeControllerManagerConfigResponse>
  void SetKubeControllerManagerConfig(KubeControllerManagerConfigT&& value) {
    m_kubeControllerManagerConfigHasBeenSet = true;
    m_kubeControllerManagerConfig = std::forward<KubeControllerManagerConfigT>(value);
  }
  template <typename KubeControllerManagerConfigT = KubeControllerManagerConfigResponse>
  Cluster& WithKubeControllerManagerConfig(KubeControllerManagerConfigT&& value) {
    SetKubeControllerManagerConfig(std::forward<KubeControllerManagerConfigT>(value));
    return *this;
  }
 private:
  Aws::String m_name;
 
  Aws::String m_arn;
 
  Aws::Utils::DateTime m_createdAt{};
 
  Aws::String m_version;
 
  Aws::String m_endpoint;
 
  Aws::String m_roleArn;
 
  VpcConfigResponse m_resourcesVpcConfig;
 
  KubernetesNetworkConfigResponse m_kubernetesNetworkConfig;
 
  Logging m_logging;
 
  Identity m_identity;
 
  ClusterStatus m_status{ClusterStatus::NOT_SET};
 
  Certificate m_certificateAuthority;
 
  Aws::String m_clientRequestToken;
 
  Aws::String m_platformVersion;
 
  Aws::Map<Aws::String, Aws::String> m_tags;
 
  Aws::Vector<EncryptionConfig> m_encryptionConfig;
 
  ConnectorConfigResponse m_connectorConfig;
 
  Aws::String m_id;
 
  ClusterHealth m_health;
 
  OutpostConfigResponse m_outpostConfig;
 
  AccessConfigResponse m_accessConfig;
 
  UpgradePolicyResponse m_upgradePolicy;
 
  ZonalShiftConfigResponse m_zonalShiftConfig;
 
  RemoteNetworkConfigResponse m_remoteNetworkConfig;
 
  ComputeConfigResponse m_computeConfig;
 
  StorageConfigResponse m_storageConfig;
 
  bool m_deletionProtection{false};
 
  ControlPlaneScalingConfig m_controlPlaneScalingConfig;
 
  KubeApiServerConfigResponse m_kubeApiServerConfig;
 
  KubeSchedulerConfigResponse m_kubeSchedulerConfig;
 
  KubeControllerManagerConfigResponse m_kubeControllerManagerConfig;
  bool m_nameHasBeenSet = false;
  bool m_arnHasBeenSet = false;
  bool m_createdAtHasBeenSet = false;
  bool m_versionHasBeenSet = false;
  bool m_endpointHasBeenSet = false;
  bool m_roleArnHasBeenSet = false;
  bool m_resourcesVpcConfigHasBeenSet = false;
  bool m_kubernetesNetworkConfigHasBeenSet = false;
  bool m_loggingHasBeenSet = false;
  bool m_identityHasBeenSet = false;
  bool m_statusHasBeenSet = false;
  bool m_certificateAuthorityHasBeenSet = false;
  bool m_clientRequestTokenHasBeenSet = false;
  bool m_platformVersionHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_encryptionConfigHasBeenSet = false;
  bool m_connectorConfigHasBeenSet = false;
  bool m_idHasBeenSet = false;
  bool m_healthHasBeenSet = false;
  bool m_outpostConfigHasBeenSet = false;
  bool m_accessConfigHasBeenSet = false;
  bool m_upgradePolicyHasBeenSet = false;
  bool m_zonalShiftConfigHasBeenSet = false;
  bool m_remoteNetworkConfigHasBeenSet = false;
  bool m_computeConfigHasBeenSet = false;
  bool m_storageConfigHasBeenSet = false;
  bool m_deletionProtectionHasBeenSet = false;
  bool m_controlPlaneScalingConfigHasBeenSet = false;
  bool m_kubeApiServerConfigHasBeenSet = false;
  bool m_kubeSchedulerConfigHasBeenSet = false;
  bool m_kubeControllerManagerConfigHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace EKS
}  // namespace Aws