Cluster.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/redshift/Redshift_EXPORTS.h>
#include <aws/redshift/model/AquaConfiguration.h>
#include <aws/redshift/model/ClusterIamRole.h>
#include <aws/redshift/model/ClusterNode.h>
#include <aws/redshift/model/ClusterParameterGroupStatus.h>
#include <aws/redshift/model/ClusterSecurityGroupMembership.h>
#include <aws/redshift/model/ClusterSnapshotCopyStatus.h>
#include <aws/redshift/model/DataTransferProgress.h>
#include <aws/redshift/model/DeferredMaintenanceWindow.h>
#include <aws/redshift/model/ElasticIpStatus.h>
#include <aws/redshift/model/Endpoint.h>
#include <aws/redshift/model/HsmStatus.h>
#include <aws/redshift/model/PendingModifiedValues.h>
#include <aws/redshift/model/ReservedNodeExchangeStatus.h>
#include <aws/redshift/model/ResizeInfo.h>
#include <aws/redshift/model/RestoreStatus.h>
#include <aws/redshift/model/ScheduleState.h>
#include <aws/redshift/model/SecondaryClusterInfo.h>
#include <aws/redshift/model/Tag.h>
#include <aws/redshift/model/VpcSecurityGroupMembership.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Xml {
class XmlNode;
}  // namespace Xml
}  // namespace Utils
namespace Redshift {
namespace Model {
 
class Cluster {
 public:
  AWS_REDSHIFT_API Cluster() = default;
  AWS_REDSHIFT_API Cluster(const Aws::Utils::Xml::XmlNode& xmlNode);
  AWS_REDSHIFT_API Cluster& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
 
  AWS_REDSHIFT_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
  AWS_REDSHIFT_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
 
 
  inline const Aws::String& GetClusterIdentifier() const { return m_clusterIdentifier; }
  inline bool ClusterIdentifierHasBeenSet() const { return m_clusterIdentifierHasBeenSet; }
  template <typename ClusterIdentifierT = Aws::String>
  void SetClusterIdentifier(ClusterIdentifierT&& value) {
    m_clusterIdentifierHasBeenSet = true;
    m_clusterIdentifier = std::forward<ClusterIdentifierT>(value);
  }
  template <typename ClusterIdentifierT = Aws::String>
  Cluster& WithClusterIdentifier(ClusterIdentifierT&& value) {
    SetClusterIdentifier(std::forward<ClusterIdentifierT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetNodeType() const { return m_nodeType; }
  inline bool NodeTypeHasBeenSet() const { return m_nodeTypeHasBeenSet; }
  template <typename NodeTypeT = Aws::String>
  void SetNodeType(NodeTypeT&& value) {
    m_nodeTypeHasBeenSet = true;
    m_nodeType = std::forward<NodeTypeT>(value);
  }
  template <typename NodeTypeT = Aws::String>
  Cluster& WithNodeType(NodeTypeT&& value) {
    SetNodeType(std::forward<NodeTypeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetClusterStatus() const { return m_clusterStatus; }
  inline bool ClusterStatusHasBeenSet() const { return m_clusterStatusHasBeenSet; }
  template <typename ClusterStatusT = Aws::String>
  void SetClusterStatus(ClusterStatusT&& value) {
    m_clusterStatusHasBeenSet = true;
    m_clusterStatus = std::forward<ClusterStatusT>(value);
  }
  template <typename ClusterStatusT = Aws::String>
  Cluster& WithClusterStatus(ClusterStatusT&& value) {
    SetClusterStatus(std::forward<ClusterStatusT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetClusterAvailabilityStatus() const { return m_clusterAvailabilityStatus; }
  inline bool ClusterAvailabilityStatusHasBeenSet() const { return m_clusterAvailabilityStatusHasBeenSet; }
  template <typename ClusterAvailabilityStatusT = Aws::String>
  void SetClusterAvailabilityStatus(ClusterAvailabilityStatusT&& value) {
    m_clusterAvailabilityStatusHasBeenSet = true;
    m_clusterAvailabilityStatus = std::forward<ClusterAvailabilityStatusT>(value);
  }
  template <typename ClusterAvailabilityStatusT = Aws::String>
  Cluster& WithClusterAvailabilityStatus(ClusterAvailabilityStatusT&& value) {
    SetClusterAvailabilityStatus(std::forward<ClusterAvailabilityStatusT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetModifyStatus() const { return m_modifyStatus; }
  inline bool ModifyStatusHasBeenSet() const { return m_modifyStatusHasBeenSet; }
  template <typename ModifyStatusT = Aws::String>
  void SetModifyStatus(ModifyStatusT&& value) {
    m_modifyStatusHasBeenSet = true;
    m_modifyStatus = std::forward<ModifyStatusT>(value);
  }
  template <typename ModifyStatusT = Aws::String>
  Cluster& WithModifyStatus(ModifyStatusT&& value) {
    SetModifyStatus(std::forward<ModifyStatusT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetMasterUsername() const { return m_masterUsername; }
  inline bool MasterUsernameHasBeenSet() const { return m_masterUsernameHasBeenSet; }
  template <typename MasterUsernameT = Aws::String>
  void SetMasterUsername(MasterUsernameT&& value) {
    m_masterUsernameHasBeenSet = true;
    m_masterUsername = std::forward<MasterUsernameT>(value);
  }
  template <typename MasterUsernameT = Aws::String>
  Cluster& WithMasterUsername(MasterUsernameT&& value) {
    SetMasterUsername(std::forward<MasterUsernameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDBName() const { return m_dBName; }
  inline bool DBNameHasBeenSet() const { return m_dBNameHasBeenSet; }
  template <typename DBNameT = Aws::String>
  void SetDBName(DBNameT&& value) {
    m_dBNameHasBeenSet = true;
    m_dBName = std::forward<DBNameT>(value);
  }
  template <typename DBNameT = Aws::String>
  Cluster& WithDBName(DBNameT&& value) {
    SetDBName(std::forward<DBNameT>(value));
    return *this;
  }
 
 
  inline const Endpoint& GetEndpoint() const { return m_endpoint; }
  inline bool EndpointHasBeenSet() const { return m_endpointHasBeenSet; }
  template <typename EndpointT = Endpoint>
  void SetEndpoint(EndpointT&& value) {
    m_endpointHasBeenSet = true;
    m_endpoint = std::forward<EndpointT>(value);
  }
  template <typename EndpointT = Endpoint>
  Cluster& WithEndpoint(EndpointT&& value) {
    SetEndpoint(std::forward<EndpointT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetClusterCreateTime() const { return m_clusterCreateTime; }
  inline bool ClusterCreateTimeHasBeenSet() const { return m_clusterCreateTimeHasBeenSet; }
  template <typename ClusterCreateTimeT = Aws::Utils::DateTime>
  void SetClusterCreateTime(ClusterCreateTimeT&& value) {
    m_clusterCreateTimeHasBeenSet = true;
    m_clusterCreateTime = std::forward<ClusterCreateTimeT>(value);
  }
  template <typename ClusterCreateTimeT = Aws::Utils::DateTime>
  Cluster& WithClusterCreateTime(ClusterCreateTimeT&& value) {
    SetClusterCreateTime(std::forward<ClusterCreateTimeT>(value));
    return *this;
  }
 
 
  inline int GetAutomatedSnapshotRetentionPeriod() const { return m_automatedSnapshotRetentionPeriod; }
  inline bool AutomatedSnapshotRetentionPeriodHasBeenSet() const { return m_automatedSnapshotRetentionPeriodHasBeenSet; }
  inline void SetAutomatedSnapshotRetentionPeriod(int value) {
    m_automatedSnapshotRetentionPeriodHasBeenSet = true;
    m_automatedSnapshotRetentionPeriod = value;
  }
  inline Cluster& WithAutomatedSnapshotRetentionPeriod(int value) {
    SetAutomatedSnapshotRetentionPeriod(value);
    return *this;
  }
 
 
  inline int GetManualSnapshotRetentionPeriod() const { return m_manualSnapshotRetentionPeriod; }
  inline bool ManualSnapshotRetentionPeriodHasBeenSet() const { return m_manualSnapshotRetentionPeriodHasBeenSet; }
  inline void SetManualSnapshotRetentionPeriod(int value) {
    m_manualSnapshotRetentionPeriodHasBeenSet = true;
    m_manualSnapshotRetentionPeriod = value;
  }
  inline Cluster& WithManualSnapshotRetentionPeriod(int value) {
    SetManualSnapshotRetentionPeriod(value);
    return *this;
  }
 
 
  inline const Aws::Vector<ClusterSecurityGroupMembership>& GetClusterSecurityGroups() const { return m_clusterSecurityGroups; }
  inline bool ClusterSecurityGroupsHasBeenSet() const { return m_clusterSecurityGroupsHasBeenSet; }
  template <typename ClusterSecurityGroupsT = Aws::Vector<ClusterSecurityGroupMembership>>
  void SetClusterSecurityGroups(ClusterSecurityGroupsT&& value) {
    m_clusterSecurityGroupsHasBeenSet = true;
    m_clusterSecurityGroups = std::forward<ClusterSecurityGroupsT>(value);
  }
  template <typename ClusterSecurityGroupsT = Aws::Vector<ClusterSecurityGroupMembership>>
  Cluster& WithClusterSecurityGroups(ClusterSecurityGroupsT&& value) {
    SetClusterSecurityGroups(std::forward<ClusterSecurityGroupsT>(value));
    return *this;
  }
  template <typename ClusterSecurityGroupsT = ClusterSecurityGroupMembership>
  Cluster& AddClusterSecurityGroups(ClusterSecurityGroupsT&& value) {
    m_clusterSecurityGroupsHasBeenSet = true;
    m_clusterSecurityGroups.emplace_back(std::forward<ClusterSecurityGroupsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<VpcSecurityGroupMembership>& GetVpcSecurityGroups() const { return m_vpcSecurityGroups; }
  inline bool VpcSecurityGroupsHasBeenSet() const { return m_vpcSecurityGroupsHasBeenSet; }
  template <typename VpcSecurityGroupsT = Aws::Vector<VpcSecurityGroupMembership>>
  void SetVpcSecurityGroups(VpcSecurityGroupsT&& value) {
    m_vpcSecurityGroupsHasBeenSet = true;
    m_vpcSecurityGroups = std::forward<VpcSecurityGroupsT>(value);
  }
  template <typename VpcSecurityGroupsT = Aws::Vector<VpcSecurityGroupMembership>>
  Cluster& WithVpcSecurityGroups(VpcSecurityGroupsT&& value) {
    SetVpcSecurityGroups(std::forward<VpcSecurityGroupsT>(value));
    return *this;
  }
  template <typename VpcSecurityGroupsT = VpcSecurityGroupMembership>
  Cluster& AddVpcSecurityGroups(VpcSecurityGroupsT&& value) {
    m_vpcSecurityGroupsHasBeenSet = true;
    m_vpcSecurityGroups.emplace_back(std::forward<VpcSecurityGroupsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ClusterParameterGroupStatus>& GetClusterParameterGroups() const { return m_clusterParameterGroups; }
  inline bool ClusterParameterGroupsHasBeenSet() const { return m_clusterParameterGroupsHasBeenSet; }
  template <typename ClusterParameterGroupsT = Aws::Vector<ClusterParameterGroupStatus>>
  void SetClusterParameterGroups(ClusterParameterGroupsT&& value) {
    m_clusterParameterGroupsHasBeenSet = true;
    m_clusterParameterGroups = std::forward<ClusterParameterGroupsT>(value);
  }
  template <typename ClusterParameterGroupsT = Aws::Vector<ClusterParameterGroupStatus>>
  Cluster& WithClusterParameterGroups(ClusterParameterGroupsT&& value) {
    SetClusterParameterGroups(std::forward<ClusterParameterGroupsT>(value));
    return *this;
  }
  template <typename ClusterParameterGroupsT = ClusterParameterGroupStatus>
  Cluster& AddClusterParameterGroups(ClusterParameterGroupsT&& value) {
    m_clusterParameterGroupsHasBeenSet = true;
    m_clusterParameterGroups.emplace_back(std::forward<ClusterParameterGroupsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetClusterSubnetGroupName() const { return m_clusterSubnetGroupName; }
  inline bool ClusterSubnetGroupNameHasBeenSet() const { return m_clusterSubnetGroupNameHasBeenSet; }
  template <typename ClusterSubnetGroupNameT = Aws::String>
  void SetClusterSubnetGroupName(ClusterSubnetGroupNameT&& value) {
    m_clusterSubnetGroupNameHasBeenSet = true;
    m_clusterSubnetGroupName = std::forward<ClusterSubnetGroupNameT>(value);
  }
  template <typename ClusterSubnetGroupNameT = Aws::String>
  Cluster& WithClusterSubnetGroupName(ClusterSubnetGroupNameT&& value) {
    SetClusterSubnetGroupName(std::forward<ClusterSubnetGroupNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetVpcId() const { return m_vpcId; }
  inline bool VpcIdHasBeenSet() const { return m_vpcIdHasBeenSet; }
  template <typename VpcIdT = Aws::String>
  void SetVpcId(VpcIdT&& value) {
    m_vpcIdHasBeenSet = true;
    m_vpcId = std::forward<VpcIdT>(value);
  }
  template <typename VpcIdT = Aws::String>
  Cluster& WithVpcId(VpcIdT&& value) {
    SetVpcId(std::forward<VpcIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAvailabilityZone() const { return m_availabilityZone; }
  inline bool AvailabilityZoneHasBeenSet() const { return m_availabilityZoneHasBeenSet; }
  template <typename AvailabilityZoneT = Aws::String>
  void SetAvailabilityZone(AvailabilityZoneT&& value) {
    m_availabilityZoneHasBeenSet = true;
    m_availabilityZone = std::forward<AvailabilityZoneT>(value);
  }
  template <typename AvailabilityZoneT = Aws::String>
  Cluster& WithAvailabilityZone(AvailabilityZoneT&& value) {
    SetAvailabilityZone(std::forward<AvailabilityZoneT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPreferredMaintenanceWindow() const { return m_preferredMaintenanceWindow; }
  inline bool PreferredMaintenanceWindowHasBeenSet() const { return m_preferredMaintenanceWindowHasBeenSet; }
  template <typename PreferredMaintenanceWindowT = Aws::String>
  void SetPreferredMaintenanceWindow(PreferredMaintenanceWindowT&& value) {
    m_preferredMaintenanceWindowHasBeenSet = true;
    m_preferredMaintenanceWindow = std::forward<PreferredMaintenanceWindowT>(value);
  }
  template <typename PreferredMaintenanceWindowT = Aws::String>
  Cluster& WithPreferredMaintenanceWindow(PreferredMaintenanceWindowT&& value) {
    SetPreferredMaintenanceWindow(std::forward<PreferredMaintenanceWindowT>(value));
    return *this;
  }
 
 
  inline const PendingModifiedValues& GetPendingModifiedValues() const { return m_pendingModifiedValues; }
  inline bool PendingModifiedValuesHasBeenSet() const { return m_pendingModifiedValuesHasBeenSet; }
  template <typename PendingModifiedValuesT = PendingModifiedValues>
  void SetPendingModifiedValues(PendingModifiedValuesT&& value) {
    m_pendingModifiedValuesHasBeenSet = true;
    m_pendingModifiedValues = std::forward<PendingModifiedValuesT>(value);
  }
  template <typename PendingModifiedValuesT = PendingModifiedValues>
  Cluster& WithPendingModifiedValues(PendingModifiedValuesT&& value) {
    SetPendingModifiedValues(std::forward<PendingModifiedValuesT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetClusterVersion() const { return m_clusterVersion; }
  inline bool ClusterVersionHasBeenSet() const { return m_clusterVersionHasBeenSet; }
  template <typename ClusterVersionT = Aws::String>
  void SetClusterVersion(ClusterVersionT&& value) {
    m_clusterVersionHasBeenSet = true;
    m_clusterVersion = std::forward<ClusterVersionT>(value);
  }
  template <typename ClusterVersionT = Aws::String>
  Cluster& WithClusterVersion(ClusterVersionT&& value) {
    SetClusterVersion(std::forward<ClusterVersionT>(value));
    return *this;
  }
 
 
  inline bool GetAllowVersionUpgrade() const { return m_allowVersionUpgrade; }
  inline bool AllowVersionUpgradeHasBeenSet() const { return m_allowVersionUpgradeHasBeenSet; }
  inline void SetAllowVersionUpgrade(bool value) {
    m_allowVersionUpgradeHasBeenSet = true;
    m_allowVersionUpgrade = value;
  }
  inline Cluster& WithAllowVersionUpgrade(bool value) {
    SetAllowVersionUpgrade(value);
    return *this;
  }
 
 
  inline int GetNumberOfNodes() const { return m_numberOfNodes; }
  inline bool NumberOfNodesHasBeenSet() const { return m_numberOfNodesHasBeenSet; }
  inline void SetNumberOfNodes(int value) {
    m_numberOfNodesHasBeenSet = true;
    m_numberOfNodes = value;
  }
  inline Cluster& WithNumberOfNodes(int value) {
    SetNumberOfNodes(value);
    return *this;
  }
 
 
  inline bool GetPubliclyAccessible() const { return m_publiclyAccessible; }
  inline bool PubliclyAccessibleHasBeenSet() const { return m_publiclyAccessibleHasBeenSet; }
  inline void SetPubliclyAccessible(bool value) {
    m_publiclyAccessibleHasBeenSet = true;
    m_publiclyAccessible = value;
  }
  inline Cluster& WithPubliclyAccessible(bool value) {
    SetPubliclyAccessible(value);
    return *this;
  }
 
 
  inline bool GetEncrypted() const { return m_encrypted; }
  inline bool EncryptedHasBeenSet() const { return m_encryptedHasBeenSet; }
  inline void SetEncrypted(bool value) {
    m_encryptedHasBeenSet = true;
    m_encrypted = value;
  }
  inline Cluster& WithEncrypted(bool value) {
    SetEncrypted(value);
    return *this;
  }
 
 
  inline const RestoreStatus& GetRestoreStatus() const { return m_restoreStatus; }
  inline bool RestoreStatusHasBeenSet() const { return m_restoreStatusHasBeenSet; }
  template <typename RestoreStatusT = RestoreStatus>
  void SetRestoreStatus(RestoreStatusT&& value) {
    m_restoreStatusHasBeenSet = true;
    m_restoreStatus = std::forward<RestoreStatusT>(value);
  }
  template <typename RestoreStatusT = RestoreStatus>
  Cluster& WithRestoreStatus(RestoreStatusT&& value) {
    SetRestoreStatus(std::forward<RestoreStatusT>(value));
    return *this;
  }
 
 
  inline const DataTransferProgress& GetDataTransferProgress() const { return m_dataTransferProgress; }
  inline bool DataTransferProgressHasBeenSet() const { return m_dataTransferProgressHasBeenSet; }
  template <typename DataTransferProgressT = DataTransferProgress>
  void SetDataTransferProgress(DataTransferProgressT&& value) {
    m_dataTransferProgressHasBeenSet = true;
    m_dataTransferProgress = std::forward<DataTransferProgressT>(value);
  }
  template <typename DataTransferProgressT = DataTransferProgress>
  Cluster& WithDataTransferProgress(DataTransferProgressT&& value) {
    SetDataTransferProgress(std::forward<DataTransferProgressT>(value));
    return *this;
  }
 
 
  inline const HsmStatus& GetHsmStatus() const { return m_hsmStatus; }
  inline bool HsmStatusHasBeenSet() const { return m_hsmStatusHasBeenSet; }
  template <typename HsmStatusT = HsmStatus>
  void SetHsmStatus(HsmStatusT&& value) {
    m_hsmStatusHasBeenSet = true;
    m_hsmStatus = std::forward<HsmStatusT>(value);
  }
  template <typename HsmStatusT = HsmStatus>
  Cluster& WithHsmStatus(HsmStatusT&& value) {
    SetHsmStatus(std::forward<HsmStatusT>(value));
    return *this;
  }
 
 
  inline const ClusterSnapshotCopyStatus& GetClusterSnapshotCopyStatus() const { return m_clusterSnapshotCopyStatus; }
  inline bool ClusterSnapshotCopyStatusHasBeenSet() const { return m_clusterSnapshotCopyStatusHasBeenSet; }
  template <typename ClusterSnapshotCopyStatusT = ClusterSnapshotCopyStatus>
  void SetClusterSnapshotCopyStatus(ClusterSnapshotCopyStatusT&& value) {
    m_clusterSnapshotCopyStatusHasBeenSet = true;
    m_clusterSnapshotCopyStatus = std::forward<ClusterSnapshotCopyStatusT>(value);
  }
  template <typename ClusterSnapshotCopyStatusT = ClusterSnapshotCopyStatus>
  Cluster& WithClusterSnapshotCopyStatus(ClusterSnapshotCopyStatusT&& value) {
    SetClusterSnapshotCopyStatus(std::forward<ClusterSnapshotCopyStatusT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetClusterPublicKey() const { return m_clusterPublicKey; }
  inline bool ClusterPublicKeyHasBeenSet() const { return m_clusterPublicKeyHasBeenSet; }
  template <typename ClusterPublicKeyT = Aws::String>
  void SetClusterPublicKey(ClusterPublicKeyT&& value) {
    m_clusterPublicKeyHasBeenSet = true;
    m_clusterPublicKey = std::forward<ClusterPublicKeyT>(value);
  }
  template <typename ClusterPublicKeyT = Aws::String>
  Cluster& WithClusterPublicKey(ClusterPublicKeyT&& value) {
    SetClusterPublicKey(std::forward<ClusterPublicKeyT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ClusterNode>& GetClusterNodes() const { return m_clusterNodes; }
  inline bool ClusterNodesHasBeenSet() const { return m_clusterNodesHasBeenSet; }
  template <typename ClusterNodesT = Aws::Vector<ClusterNode>>
  void SetClusterNodes(ClusterNodesT&& value) {
    m_clusterNodesHasBeenSet = true;
    m_clusterNodes = std::forward<ClusterNodesT>(value);
  }
  template <typename ClusterNodesT = Aws::Vector<ClusterNode>>
  Cluster& WithClusterNodes(ClusterNodesT&& value) {
    SetClusterNodes(std::forward<ClusterNodesT>(value));
    return *this;
  }
  template <typename ClusterNodesT = ClusterNode>
  Cluster& AddClusterNodes(ClusterNodesT&& value) {
    m_clusterNodesHasBeenSet = true;
    m_clusterNodes.emplace_back(std::forward<ClusterNodesT>(value));
    return *this;
  }
 
 
  inline const ElasticIpStatus& GetElasticIpStatus() const { return m_elasticIpStatus; }
  inline bool ElasticIpStatusHasBeenSet() const { return m_elasticIpStatusHasBeenSet; }
  template <typename ElasticIpStatusT = ElasticIpStatus>
  void SetElasticIpStatus(ElasticIpStatusT&& value) {
    m_elasticIpStatusHasBeenSet = true;
    m_elasticIpStatus = std::forward<ElasticIpStatusT>(value);
  }
  template <typename ElasticIpStatusT = ElasticIpStatus>
  Cluster& WithElasticIpStatus(ElasticIpStatusT&& value) {
    SetElasticIpStatus(std::forward<ElasticIpStatusT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetClusterRevisionNumber() const { return m_clusterRevisionNumber; }
  inline bool ClusterRevisionNumberHasBeenSet() const { return m_clusterRevisionNumberHasBeenSet; }
  template <typename ClusterRevisionNumberT = Aws::String>
  void SetClusterRevisionNumber(ClusterRevisionNumberT&& value) {
    m_clusterRevisionNumberHasBeenSet = true;
    m_clusterRevisionNumber = std::forward<ClusterRevisionNumberT>(value);
  }
  template <typename ClusterRevisionNumberT = Aws::String>
  Cluster& WithClusterRevisionNumber(ClusterRevisionNumberT&& value) {
    SetClusterRevisionNumber(std::forward<ClusterRevisionNumberT>(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>>
  Cluster& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsT = Tag>
  Cluster& AddTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace_back(std::forward<TagsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetKmsKeyId() const { return m_kmsKeyId; }
  inline bool KmsKeyIdHasBeenSet() const { return m_kmsKeyIdHasBeenSet; }
  template <typename KmsKeyIdT = Aws::String>
  void SetKmsKeyId(KmsKeyIdT&& value) {
    m_kmsKeyIdHasBeenSet = true;
    m_kmsKeyId = std::forward<KmsKeyIdT>(value);
  }
  template <typename KmsKeyIdT = Aws::String>
  Cluster& WithKmsKeyId(KmsKeyIdT&& value) {
    SetKmsKeyId(std::forward<KmsKeyIdT>(value));
    return *this;
  }
 
 
  inline bool GetEnhancedVpcRouting() const { return m_enhancedVpcRouting; }
  inline bool EnhancedVpcRoutingHasBeenSet() const { return m_enhancedVpcRoutingHasBeenSet; }
  inline void SetEnhancedVpcRouting(bool value) {
    m_enhancedVpcRoutingHasBeenSet = true;
    m_enhancedVpcRouting = value;
  }
  inline Cluster& WithEnhancedVpcRouting(bool value) {
    SetEnhancedVpcRouting(value);
    return *this;
  }
 
 
  inline const Aws::Vector<ClusterIamRole>& GetIamRoles() const { return m_iamRoles; }
  inline bool IamRolesHasBeenSet() const { return m_iamRolesHasBeenSet; }
  template <typename IamRolesT = Aws::Vector<ClusterIamRole>>
  void SetIamRoles(IamRolesT&& value) {
    m_iamRolesHasBeenSet = true;
    m_iamRoles = std::forward<IamRolesT>(value);
  }
  template <typename IamRolesT = Aws::Vector<ClusterIamRole>>
  Cluster& WithIamRoles(IamRolesT&& value) {
    SetIamRoles(std::forward<IamRolesT>(value));
    return *this;
  }
  template <typename IamRolesT = ClusterIamRole>
  Cluster& AddIamRoles(IamRolesT&& value) {
    m_iamRolesHasBeenSet = true;
    m_iamRoles.emplace_back(std::forward<IamRolesT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetPendingActions() const { return m_pendingActions; }
  inline bool PendingActionsHasBeenSet() const { return m_pendingActionsHasBeenSet; }
  template <typename PendingActionsT = Aws::Vector<Aws::String>>
  void SetPendingActions(PendingActionsT&& value) {
    m_pendingActionsHasBeenSet = true;
    m_pendingActions = std::forward<PendingActionsT>(value);
  }
  template <typename PendingActionsT = Aws::Vector<Aws::String>>
  Cluster& WithPendingActions(PendingActionsT&& value) {
    SetPendingActions(std::forward<PendingActionsT>(value));
    return *this;
  }
  template <typename PendingActionsT = Aws::String>
  Cluster& AddPendingActions(PendingActionsT&& value) {
    m_pendingActionsHasBeenSet = true;
    m_pendingActions.emplace_back(std::forward<PendingActionsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetMaintenanceTrackName() const { return m_maintenanceTrackName; }
  inline bool MaintenanceTrackNameHasBeenSet() const { return m_maintenanceTrackNameHasBeenSet; }
  template <typename MaintenanceTrackNameT = Aws::String>
  void SetMaintenanceTrackName(MaintenanceTrackNameT&& value) {
    m_maintenanceTrackNameHasBeenSet = true;
    m_maintenanceTrackName = std::forward<MaintenanceTrackNameT>(value);
  }
  template <typename MaintenanceTrackNameT = Aws::String>
  Cluster& WithMaintenanceTrackName(MaintenanceTrackNameT&& value) {
    SetMaintenanceTrackName(std::forward<MaintenanceTrackNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetElasticResizeNumberOfNodeOptions() const { return m_elasticResizeNumberOfNodeOptions; }
  inline bool ElasticResizeNumberOfNodeOptionsHasBeenSet() const { return m_elasticResizeNumberOfNodeOptionsHasBeenSet; }
  template <typename ElasticResizeNumberOfNodeOptionsT = Aws::String>
  void SetElasticResizeNumberOfNodeOptions(ElasticResizeNumberOfNodeOptionsT&& value) {
    m_elasticResizeNumberOfNodeOptionsHasBeenSet = true;
    m_elasticResizeNumberOfNodeOptions = std::forward<ElasticResizeNumberOfNodeOptionsT>(value);
  }
  template <typename ElasticResizeNumberOfNodeOptionsT = Aws::String>
  Cluster& WithElasticResizeNumberOfNodeOptions(ElasticResizeNumberOfNodeOptionsT&& value) {
    SetElasticResizeNumberOfNodeOptions(std::forward<ElasticResizeNumberOfNodeOptionsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<DeferredMaintenanceWindow>& GetDeferredMaintenanceWindows() const { return m_deferredMaintenanceWindows; }
  inline bool DeferredMaintenanceWindowsHasBeenSet() const { return m_deferredMaintenanceWindowsHasBeenSet; }
  template <typename DeferredMaintenanceWindowsT = Aws::Vector<DeferredMaintenanceWindow>>
  void SetDeferredMaintenanceWindows(DeferredMaintenanceWindowsT&& value) {
    m_deferredMaintenanceWindowsHasBeenSet = true;
    m_deferredMaintenanceWindows = std::forward<DeferredMaintenanceWindowsT>(value);
  }
  template <typename DeferredMaintenanceWindowsT = Aws::Vector<DeferredMaintenanceWindow>>
  Cluster& WithDeferredMaintenanceWindows(DeferredMaintenanceWindowsT&& value) {
    SetDeferredMaintenanceWindows(std::forward<DeferredMaintenanceWindowsT>(value));
    return *this;
  }
  template <typename DeferredMaintenanceWindowsT = DeferredMaintenanceWindow>
  Cluster& AddDeferredMaintenanceWindows(DeferredMaintenanceWindowsT&& value) {
    m_deferredMaintenanceWindowsHasBeenSet = true;
    m_deferredMaintenanceWindows.emplace_back(std::forward<DeferredMaintenanceWindowsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSnapshotScheduleIdentifier() const { return m_snapshotScheduleIdentifier; }
  inline bool SnapshotScheduleIdentifierHasBeenSet() const { return m_snapshotScheduleIdentifierHasBeenSet; }
  template <typename SnapshotScheduleIdentifierT = Aws::String>
  void SetSnapshotScheduleIdentifier(SnapshotScheduleIdentifierT&& value) {
    m_snapshotScheduleIdentifierHasBeenSet = true;
    m_snapshotScheduleIdentifier = std::forward<SnapshotScheduleIdentifierT>(value);
  }
  template <typename SnapshotScheduleIdentifierT = Aws::String>
  Cluster& WithSnapshotScheduleIdentifier(SnapshotScheduleIdentifierT&& value) {
    SetSnapshotScheduleIdentifier(std::forward<SnapshotScheduleIdentifierT>(value));
    return *this;
  }
 
 
  inline ScheduleState GetSnapshotScheduleState() const { return m_snapshotScheduleState; }
  inline bool SnapshotScheduleStateHasBeenSet() const { return m_snapshotScheduleStateHasBeenSet; }
  inline void SetSnapshotScheduleState(ScheduleState value) {
    m_snapshotScheduleStateHasBeenSet = true;
    m_snapshotScheduleState = value;
  }
  inline Cluster& WithSnapshotScheduleState(ScheduleState value) {
    SetSnapshotScheduleState(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetExpectedNextSnapshotScheduleTime() const { return m_expectedNextSnapshotScheduleTime; }
  inline bool ExpectedNextSnapshotScheduleTimeHasBeenSet() const { return m_expectedNextSnapshotScheduleTimeHasBeenSet; }
  template <typename ExpectedNextSnapshotScheduleTimeT = Aws::Utils::DateTime>
  void SetExpectedNextSnapshotScheduleTime(ExpectedNextSnapshotScheduleTimeT&& value) {
    m_expectedNextSnapshotScheduleTimeHasBeenSet = true;
    m_expectedNextSnapshotScheduleTime = std::forward<ExpectedNextSnapshotScheduleTimeT>(value);
  }
  template <typename ExpectedNextSnapshotScheduleTimeT = Aws::Utils::DateTime>
  Cluster& WithExpectedNextSnapshotScheduleTime(ExpectedNextSnapshotScheduleTimeT&& value) {
    SetExpectedNextSnapshotScheduleTime(std::forward<ExpectedNextSnapshotScheduleTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetExpectedNextSnapshotScheduleTimeStatus() const { return m_expectedNextSnapshotScheduleTimeStatus; }
  inline bool ExpectedNextSnapshotScheduleTimeStatusHasBeenSet() const { return m_expectedNextSnapshotScheduleTimeStatusHasBeenSet; }
  template <typename ExpectedNextSnapshotScheduleTimeStatusT = Aws::String>
  void SetExpectedNextSnapshotScheduleTimeStatus(ExpectedNextSnapshotScheduleTimeStatusT&& value) {
    m_expectedNextSnapshotScheduleTimeStatusHasBeenSet = true;
    m_expectedNextSnapshotScheduleTimeStatus = std::forward<ExpectedNextSnapshotScheduleTimeStatusT>(value);
  }
  template <typename ExpectedNextSnapshotScheduleTimeStatusT = Aws::String>
  Cluster& WithExpectedNextSnapshotScheduleTimeStatus(ExpectedNextSnapshotScheduleTimeStatusT&& value) {
    SetExpectedNextSnapshotScheduleTimeStatus(std::forward<ExpectedNextSnapshotScheduleTimeStatusT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetNextMaintenanceWindowStartTime() const { return m_nextMaintenanceWindowStartTime; }
  inline bool NextMaintenanceWindowStartTimeHasBeenSet() const { return m_nextMaintenanceWindowStartTimeHasBeenSet; }
  template <typename NextMaintenanceWindowStartTimeT = Aws::Utils::DateTime>
  void SetNextMaintenanceWindowStartTime(NextMaintenanceWindowStartTimeT&& value) {
    m_nextMaintenanceWindowStartTimeHasBeenSet = true;
    m_nextMaintenanceWindowStartTime = std::forward<NextMaintenanceWindowStartTimeT>(value);
  }
  template <typename NextMaintenanceWindowStartTimeT = Aws::Utils::DateTime>
  Cluster& WithNextMaintenanceWindowStartTime(NextMaintenanceWindowStartTimeT&& value) {
    SetNextMaintenanceWindowStartTime(std::forward<NextMaintenanceWindowStartTimeT>(value));
    return *this;
  }
 
 
  inline const ResizeInfo& GetResizeInfo() const { return m_resizeInfo; }
  inline bool ResizeInfoHasBeenSet() const { return m_resizeInfoHasBeenSet; }
  template <typename ResizeInfoT = ResizeInfo>
  void SetResizeInfo(ResizeInfoT&& value) {
    m_resizeInfoHasBeenSet = true;
    m_resizeInfo = std::forward<ResizeInfoT>(value);
  }
  template <typename ResizeInfoT = ResizeInfo>
  Cluster& WithResizeInfo(ResizeInfoT&& value) {
    SetResizeInfo(std::forward<ResizeInfoT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAvailabilityZoneRelocationStatus() const { return m_availabilityZoneRelocationStatus; }
  inline bool AvailabilityZoneRelocationStatusHasBeenSet() const { return m_availabilityZoneRelocationStatusHasBeenSet; }
  template <typename AvailabilityZoneRelocationStatusT = Aws::String>
  void SetAvailabilityZoneRelocationStatus(AvailabilityZoneRelocationStatusT&& value) {
    m_availabilityZoneRelocationStatusHasBeenSet = true;
    m_availabilityZoneRelocationStatus = std::forward<AvailabilityZoneRelocationStatusT>(value);
  }
  template <typename AvailabilityZoneRelocationStatusT = Aws::String>
  Cluster& WithAvailabilityZoneRelocationStatus(AvailabilityZoneRelocationStatusT&& value) {
    SetAvailabilityZoneRelocationStatus(std::forward<AvailabilityZoneRelocationStatusT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetClusterNamespaceArn() const { return m_clusterNamespaceArn; }
  inline bool ClusterNamespaceArnHasBeenSet() const { return m_clusterNamespaceArnHasBeenSet; }
  template <typename ClusterNamespaceArnT = Aws::String>
  void SetClusterNamespaceArn(ClusterNamespaceArnT&& value) {
    m_clusterNamespaceArnHasBeenSet = true;
    m_clusterNamespaceArn = std::forward<ClusterNamespaceArnT>(value);
  }
  template <typename ClusterNamespaceArnT = Aws::String>
  Cluster& WithClusterNamespaceArn(ClusterNamespaceArnT&& value) {
    SetClusterNamespaceArn(std::forward<ClusterNamespaceArnT>(value));
    return *this;
  }
 
 
  inline long long GetTotalStorageCapacityInMegaBytes() const { return m_totalStorageCapacityInMegaBytes; }
  inline bool TotalStorageCapacityInMegaBytesHasBeenSet() const { return m_totalStorageCapacityInMegaBytesHasBeenSet; }
  inline void SetTotalStorageCapacityInMegaBytes(long long value) {
    m_totalStorageCapacityInMegaBytesHasBeenSet = true;
    m_totalStorageCapacityInMegaBytes = value;
  }
  inline Cluster& WithTotalStorageCapacityInMegaBytes(long long value) {
    SetTotalStorageCapacityInMegaBytes(value);
    return *this;
  }
 
 
  inline const AquaConfiguration& GetAquaConfiguration() const { return m_aquaConfiguration; }
  inline bool AquaConfigurationHasBeenSet() const { return m_aquaConfigurationHasBeenSet; }
  template <typename AquaConfigurationT = AquaConfiguration>
  void SetAquaConfiguration(AquaConfigurationT&& value) {
    m_aquaConfigurationHasBeenSet = true;
    m_aquaConfiguration = std::forward<AquaConfigurationT>(value);
  }
  template <typename AquaConfigurationT = AquaConfiguration>
  Cluster& WithAquaConfiguration(AquaConfigurationT&& value) {
    SetAquaConfiguration(std::forward<AquaConfigurationT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDefaultIamRoleArn() const { return m_defaultIamRoleArn; }
  inline bool DefaultIamRoleArnHasBeenSet() const { return m_defaultIamRoleArnHasBeenSet; }
  template <typename DefaultIamRoleArnT = Aws::String>
  void SetDefaultIamRoleArn(DefaultIamRoleArnT&& value) {
    m_defaultIamRoleArnHasBeenSet = true;
    m_defaultIamRoleArn = std::forward<DefaultIamRoleArnT>(value);
  }
  template <typename DefaultIamRoleArnT = Aws::String>
  Cluster& WithDefaultIamRoleArn(DefaultIamRoleArnT&& value) {
    SetDefaultIamRoleArn(std::forward<DefaultIamRoleArnT>(value));
    return *this;
  }
 
 
  inline const ReservedNodeExchangeStatus& GetReservedNodeExchangeStatus() const { return m_reservedNodeExchangeStatus; }
  inline bool ReservedNodeExchangeStatusHasBeenSet() const { return m_reservedNodeExchangeStatusHasBeenSet; }
  template <typename ReservedNodeExchangeStatusT = ReservedNodeExchangeStatus>
  void SetReservedNodeExchangeStatus(ReservedNodeExchangeStatusT&& value) {
    m_reservedNodeExchangeStatusHasBeenSet = true;
    m_reservedNodeExchangeStatus = std::forward<ReservedNodeExchangeStatusT>(value);
  }
  template <typename ReservedNodeExchangeStatusT = ReservedNodeExchangeStatus>
  Cluster& WithReservedNodeExchangeStatus(ReservedNodeExchangeStatusT&& value) {
    SetReservedNodeExchangeStatus(std::forward<ReservedNodeExchangeStatusT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCustomDomainName() const { return m_customDomainName; }
  inline bool CustomDomainNameHasBeenSet() const { return m_customDomainNameHasBeenSet; }
  template <typename CustomDomainNameT = Aws::String>
  void SetCustomDomainName(CustomDomainNameT&& value) {
    m_customDomainNameHasBeenSet = true;
    m_customDomainName = std::forward<CustomDomainNameT>(value);
  }
  template <typename CustomDomainNameT = Aws::String>
  Cluster& WithCustomDomainName(CustomDomainNameT&& value) {
    SetCustomDomainName(std::forward<CustomDomainNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCustomDomainCertificateArn() const { return m_customDomainCertificateArn; }
  inline bool CustomDomainCertificateArnHasBeenSet() const { return m_customDomainCertificateArnHasBeenSet; }
  template <typename CustomDomainCertificateArnT = Aws::String>
  void SetCustomDomainCertificateArn(CustomDomainCertificateArnT&& value) {
    m_customDomainCertificateArnHasBeenSet = true;
    m_customDomainCertificateArn = std::forward<CustomDomainCertificateArnT>(value);
  }
  template <typename CustomDomainCertificateArnT = Aws::String>
  Cluster& WithCustomDomainCertificateArn(CustomDomainCertificateArnT&& value) {
    SetCustomDomainCertificateArn(std::forward<CustomDomainCertificateArnT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCustomDomainCertificateExpiryDate() const { return m_customDomainCertificateExpiryDate; }
  inline bool CustomDomainCertificateExpiryDateHasBeenSet() const { return m_customDomainCertificateExpiryDateHasBeenSet; }
  template <typename CustomDomainCertificateExpiryDateT = Aws::Utils::DateTime>
  void SetCustomDomainCertificateExpiryDate(CustomDomainCertificateExpiryDateT&& value) {
    m_customDomainCertificateExpiryDateHasBeenSet = true;
    m_customDomainCertificateExpiryDate = std::forward<CustomDomainCertificateExpiryDateT>(value);
  }
  template <typename CustomDomainCertificateExpiryDateT = Aws::Utils::DateTime>
  Cluster& WithCustomDomainCertificateExpiryDate(CustomDomainCertificateExpiryDateT&& value) {
    SetCustomDomainCertificateExpiryDate(std::forward<CustomDomainCertificateExpiryDateT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetMasterPasswordSecretArn() const { return m_masterPasswordSecretArn; }
  inline bool MasterPasswordSecretArnHasBeenSet() const { return m_masterPasswordSecretArnHasBeenSet; }
  template <typename MasterPasswordSecretArnT = Aws::String>
  void SetMasterPasswordSecretArn(MasterPasswordSecretArnT&& value) {
    m_masterPasswordSecretArnHasBeenSet = true;
    m_masterPasswordSecretArn = std::forward<MasterPasswordSecretArnT>(value);
  }
  template <typename MasterPasswordSecretArnT = Aws::String>
  Cluster& WithMasterPasswordSecretArn(MasterPasswordSecretArnT&& value) {
    SetMasterPasswordSecretArn(std::forward<MasterPasswordSecretArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetMasterPasswordSecretKmsKeyId() const { return m_masterPasswordSecretKmsKeyId; }
  inline bool MasterPasswordSecretKmsKeyIdHasBeenSet() const { return m_masterPasswordSecretKmsKeyIdHasBeenSet; }
  template <typename MasterPasswordSecretKmsKeyIdT = Aws::String>
  void SetMasterPasswordSecretKmsKeyId(MasterPasswordSecretKmsKeyIdT&& value) {
    m_masterPasswordSecretKmsKeyIdHasBeenSet = true;
    m_masterPasswordSecretKmsKeyId = std::forward<MasterPasswordSecretKmsKeyIdT>(value);
  }
  template <typename MasterPasswordSecretKmsKeyIdT = Aws::String>
  Cluster& WithMasterPasswordSecretKmsKeyId(MasterPasswordSecretKmsKeyIdT&& value) {
    SetMasterPasswordSecretKmsKeyId(std::forward<MasterPasswordSecretKmsKeyIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetIpAddressType() const { return m_ipAddressType; }
  inline bool IpAddressTypeHasBeenSet() const { return m_ipAddressTypeHasBeenSet; }
  template <typename IpAddressTypeT = Aws::String>
  void SetIpAddressType(IpAddressTypeT&& value) {
    m_ipAddressTypeHasBeenSet = true;
    m_ipAddressType = std::forward<IpAddressTypeT>(value);
  }
  template <typename IpAddressTypeT = Aws::String>
  Cluster& WithIpAddressType(IpAddressTypeT&& value) {
    SetIpAddressType(std::forward<IpAddressTypeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetMultiAZ() const { return m_multiAZ; }
  inline bool MultiAZHasBeenSet() const { return m_multiAZHasBeenSet; }
  template <typename MultiAZT = Aws::String>
  void SetMultiAZ(MultiAZT&& value) {
    m_multiAZHasBeenSet = true;
    m_multiAZ = std::forward<MultiAZT>(value);
  }
  template <typename MultiAZT = Aws::String>
  Cluster& WithMultiAZ(MultiAZT&& value) {
    SetMultiAZ(std::forward<MultiAZT>(value));
    return *this;
  }
 
 
  inline const SecondaryClusterInfo& GetMultiAZSecondary() const { return m_multiAZSecondary; }
  inline bool MultiAZSecondaryHasBeenSet() const { return m_multiAZSecondaryHasBeenSet; }
  template <typename MultiAZSecondaryT = SecondaryClusterInfo>
  void SetMultiAZSecondary(MultiAZSecondaryT&& value) {
    m_multiAZSecondaryHasBeenSet = true;
    m_multiAZSecondary = std::forward<MultiAZSecondaryT>(value);
  }
  template <typename MultiAZSecondaryT = SecondaryClusterInfo>
  Cluster& WithMultiAZSecondary(MultiAZSecondaryT&& value) {
    SetMultiAZSecondary(std::forward<MultiAZSecondaryT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetLakehouseRegistrationStatus() const { return m_lakehouseRegistrationStatus; }
  inline bool LakehouseRegistrationStatusHasBeenSet() const { return m_lakehouseRegistrationStatusHasBeenSet; }
  template <typename LakehouseRegistrationStatusT = Aws::String>
  void SetLakehouseRegistrationStatus(LakehouseRegistrationStatusT&& value) {
    m_lakehouseRegistrationStatusHasBeenSet = true;
    m_lakehouseRegistrationStatus = std::forward<LakehouseRegistrationStatusT>(value);
  }
  template <typename LakehouseRegistrationStatusT = Aws::String>
  Cluster& WithLakehouseRegistrationStatus(LakehouseRegistrationStatusT&& value) {
    SetLakehouseRegistrationStatus(std::forward<LakehouseRegistrationStatusT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCatalogArn() const { return m_catalogArn; }
  inline bool CatalogArnHasBeenSet() const { return m_catalogArnHasBeenSet; }
  template <typename CatalogArnT = Aws::String>
  void SetCatalogArn(CatalogArnT&& value) {
    m_catalogArnHasBeenSet = true;
    m_catalogArn = std::forward<CatalogArnT>(value);
  }
  template <typename CatalogArnT = Aws::String>
  Cluster& WithCatalogArn(CatalogArnT&& value) {
    SetCatalogArn(std::forward<CatalogArnT>(value));
    return *this;
  }
 private:
  Aws::String m_clusterIdentifier;
 
  Aws::String m_nodeType;
 
  Aws::String m_clusterStatus;
 
  Aws::String m_clusterAvailabilityStatus;
 
  Aws::String m_modifyStatus;
 
  Aws::String m_masterUsername;
 
  Aws::String m_dBName;
 
  Endpoint m_endpoint;
 
  Aws::Utils::DateTime m_clusterCreateTime{};
 
  int m_automatedSnapshotRetentionPeriod{0};
 
  int m_manualSnapshotRetentionPeriod{0};
 
  Aws::Vector<ClusterSecurityGroupMembership> m_clusterSecurityGroups;
 
  Aws::Vector<VpcSecurityGroupMembership> m_vpcSecurityGroups;
 
  Aws::Vector<ClusterParameterGroupStatus> m_clusterParameterGroups;
 
  Aws::String m_clusterSubnetGroupName;
 
  Aws::String m_vpcId;
 
  Aws::String m_availabilityZone;
 
  Aws::String m_preferredMaintenanceWindow;
 
  PendingModifiedValues m_pendingModifiedValues;
 
  Aws::String m_clusterVersion;
 
  bool m_allowVersionUpgrade{false};
 
  int m_numberOfNodes{0};
 
  bool m_publiclyAccessible{false};
 
  bool m_encrypted{false};
 
  RestoreStatus m_restoreStatus;
 
  DataTransferProgress m_dataTransferProgress;
 
  HsmStatus m_hsmStatus;
 
  ClusterSnapshotCopyStatus m_clusterSnapshotCopyStatus;
 
  Aws::String m_clusterPublicKey;
 
  Aws::Vector<ClusterNode> m_clusterNodes;
 
  ElasticIpStatus m_elasticIpStatus;
 
  Aws::String m_clusterRevisionNumber;
 
  Aws::Vector<Tag> m_tags;
 
  Aws::String m_kmsKeyId;
 
  bool m_enhancedVpcRouting{false};
 
  Aws::Vector<ClusterIamRole> m_iamRoles;
 
  Aws::Vector<Aws::String> m_pendingActions;
 
  Aws::String m_maintenanceTrackName;
 
  Aws::String m_elasticResizeNumberOfNodeOptions;
 
  Aws::Vector<DeferredMaintenanceWindow> m_deferredMaintenanceWindows;
 
  Aws::String m_snapshotScheduleIdentifier;
 
  ScheduleState m_snapshotScheduleState{ScheduleState::NOT_SET};
 
  Aws::Utils::DateTime m_expectedNextSnapshotScheduleTime{};
 
  Aws::String m_expectedNextSnapshotScheduleTimeStatus;
 
  Aws::Utils::DateTime m_nextMaintenanceWindowStartTime{};
 
  ResizeInfo m_resizeInfo;
 
  Aws::String m_availabilityZoneRelocationStatus;
 
  Aws::String m_clusterNamespaceArn;
 
  long long m_totalStorageCapacityInMegaBytes{0};
 
  AquaConfiguration m_aquaConfiguration;
 
  Aws::String m_defaultIamRoleArn;
 
  ReservedNodeExchangeStatus m_reservedNodeExchangeStatus;
 
  Aws::String m_customDomainName;
 
  Aws::String m_customDomainCertificateArn;
 
  Aws::Utils::DateTime m_customDomainCertificateExpiryDate{};
 
  Aws::String m_masterPasswordSecretArn;
 
  Aws::String m_masterPasswordSecretKmsKeyId;
 
  Aws::String m_ipAddressType;
 
  Aws::String m_multiAZ;
 
  SecondaryClusterInfo m_multiAZSecondary;
 
  Aws::String m_lakehouseRegistrationStatus;
 
  Aws::String m_catalogArn;
  bool m_clusterIdentifierHasBeenSet = false;
  bool m_nodeTypeHasBeenSet = false;
  bool m_clusterStatusHasBeenSet = false;
  bool m_clusterAvailabilityStatusHasBeenSet = false;
  bool m_modifyStatusHasBeenSet = false;
  bool m_masterUsernameHasBeenSet = false;
  bool m_dBNameHasBeenSet = false;
  bool m_endpointHasBeenSet = false;
  bool m_clusterCreateTimeHasBeenSet = false;
  bool m_automatedSnapshotRetentionPeriodHasBeenSet = false;
  bool m_manualSnapshotRetentionPeriodHasBeenSet = false;
  bool m_clusterSecurityGroupsHasBeenSet = false;
  bool m_vpcSecurityGroupsHasBeenSet = false;
  bool m_clusterParameterGroupsHasBeenSet = false;
  bool m_clusterSubnetGroupNameHasBeenSet = false;
  bool m_vpcIdHasBeenSet = false;
  bool m_availabilityZoneHasBeenSet = false;
  bool m_preferredMaintenanceWindowHasBeenSet = false;
  bool m_pendingModifiedValuesHasBeenSet = false;
  bool m_clusterVersionHasBeenSet = false;
  bool m_allowVersionUpgradeHasBeenSet = false;
  bool m_numberOfNodesHasBeenSet = false;
  bool m_publiclyAccessibleHasBeenSet = false;
  bool m_encryptedHasBeenSet = false;
  bool m_restoreStatusHasBeenSet = false;
  bool m_dataTransferProgressHasBeenSet = false;
  bool m_hsmStatusHasBeenSet = false;
  bool m_clusterSnapshotCopyStatusHasBeenSet = false;
  bool m_clusterPublicKeyHasBeenSet = false;
  bool m_clusterNodesHasBeenSet = false;
  bool m_elasticIpStatusHasBeenSet = false;
  bool m_clusterRevisionNumberHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_kmsKeyIdHasBeenSet = false;
  bool m_enhancedVpcRoutingHasBeenSet = false;
  bool m_iamRolesHasBeenSet = false;
  bool m_pendingActionsHasBeenSet = false;
  bool m_maintenanceTrackNameHasBeenSet = false;
  bool m_elasticResizeNumberOfNodeOptionsHasBeenSet = false;
  bool m_deferredMaintenanceWindowsHasBeenSet = false;
  bool m_snapshotScheduleIdentifierHasBeenSet = false;
  bool m_snapshotScheduleStateHasBeenSet = false;
  bool m_expectedNextSnapshotScheduleTimeHasBeenSet = false;
  bool m_expectedNextSnapshotScheduleTimeStatusHasBeenSet = false;
  bool m_nextMaintenanceWindowStartTimeHasBeenSet = false;
  bool m_resizeInfoHasBeenSet = false;
  bool m_availabilityZoneRelocationStatusHasBeenSet = false;
  bool m_clusterNamespaceArnHasBeenSet = false;
  bool m_totalStorageCapacityInMegaBytesHasBeenSet = false;
  bool m_aquaConfigurationHasBeenSet = false;
  bool m_defaultIamRoleArnHasBeenSet = false;
  bool m_reservedNodeExchangeStatusHasBeenSet = false;
  bool m_customDomainNameHasBeenSet = false;
  bool m_customDomainCertificateArnHasBeenSet = false;
  bool m_customDomainCertificateExpiryDateHasBeenSet = false;
  bool m_masterPasswordSecretArnHasBeenSet = false;
  bool m_masterPasswordSecretKmsKeyIdHasBeenSet = false;
  bool m_ipAddressTypeHasBeenSet = false;
  bool m_multiAZHasBeenSet = false;
  bool m_multiAZSecondaryHasBeenSet = false;
  bool m_lakehouseRegistrationStatusHasBeenSet = false;
  bool m_catalogArnHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Redshift
}  // namespace Aws