DBCluster.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/docdb/DocDB_EXPORTS.h>
#include <aws/docdb/model/ClusterMasterUserSecret.h>
#include <aws/docdb/model/DBClusterMember.h>
#include <aws/docdb/model/DBClusterRole.h>
#include <aws/docdb/model/ServerlessV2ScalingConfigurationInfo.h>
#include <aws/docdb/model/VpcSecurityGroupMembership.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Xml {
class XmlNode;
}  // namespace Xml
}  // namespace Utils
namespace DocDB {
namespace Model {
 
class DBCluster {
 public:
  AWS_DOCDB_API DBCluster() = default;
  AWS_DOCDB_API DBCluster(const Aws::Utils::Xml::XmlNode& xmlNode);
  AWS_DOCDB_API DBCluster& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
 
  AWS_DOCDB_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
  AWS_DOCDB_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
 
 
  inline const Aws::Vector<Aws::String>& GetAvailabilityZones() const { return m_availabilityZones; }
  inline bool AvailabilityZonesHasBeenSet() const { return m_availabilityZonesHasBeenSet; }
  template <typename AvailabilityZonesT = Aws::Vector<Aws::String>>
  void SetAvailabilityZones(AvailabilityZonesT&& value) {
    m_availabilityZonesHasBeenSet = true;
    m_availabilityZones = std::forward<AvailabilityZonesT>(value);
  }
  template <typename AvailabilityZonesT = Aws::Vector<Aws::String>>
  DBCluster& WithAvailabilityZones(AvailabilityZonesT&& value) {
    SetAvailabilityZones(std::forward<AvailabilityZonesT>(value));
    return *this;
  }
  template <typename AvailabilityZonesT = Aws::String>
  DBCluster& AddAvailabilityZones(AvailabilityZonesT&& value) {
    m_availabilityZonesHasBeenSet = true;
    m_availabilityZones.emplace_back(std::forward<AvailabilityZonesT>(value));
    return *this;
  }
 
 
  inline int GetBackupRetentionPeriod() const { return m_backupRetentionPeriod; }
  inline bool BackupRetentionPeriodHasBeenSet() const { return m_backupRetentionPeriodHasBeenSet; }
  inline void SetBackupRetentionPeriod(int value) {
    m_backupRetentionPeriodHasBeenSet = true;
    m_backupRetentionPeriod = value;
  }
  inline DBCluster& WithBackupRetentionPeriod(int value) {
    SetBackupRetentionPeriod(value);
    return *this;
  }
 
 
  inline const Aws::String& GetDBClusterIdentifier() const { return m_dBClusterIdentifier; }
  inline bool DBClusterIdentifierHasBeenSet() const { return m_dBClusterIdentifierHasBeenSet; }
  template <typename DBClusterIdentifierT = Aws::String>
  void SetDBClusterIdentifier(DBClusterIdentifierT&& value) {
    m_dBClusterIdentifierHasBeenSet = true;
    m_dBClusterIdentifier = std::forward<DBClusterIdentifierT>(value);
  }
  template <typename DBClusterIdentifierT = Aws::String>
  DBCluster& WithDBClusterIdentifier(DBClusterIdentifierT&& value) {
    SetDBClusterIdentifier(std::forward<DBClusterIdentifierT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDBClusterParameterGroup() const { return m_dBClusterParameterGroup; }
  inline bool DBClusterParameterGroupHasBeenSet() const { return m_dBClusterParameterGroupHasBeenSet; }
  template <typename DBClusterParameterGroupT = Aws::String>
  void SetDBClusterParameterGroup(DBClusterParameterGroupT&& value) {
    m_dBClusterParameterGroupHasBeenSet = true;
    m_dBClusterParameterGroup = std::forward<DBClusterParameterGroupT>(value);
  }
  template <typename DBClusterParameterGroupT = Aws::String>
  DBCluster& WithDBClusterParameterGroup(DBClusterParameterGroupT&& value) {
    SetDBClusterParameterGroup(std::forward<DBClusterParameterGroupT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDBSubnetGroup() const { return m_dBSubnetGroup; }
  inline bool DBSubnetGroupHasBeenSet() const { return m_dBSubnetGroupHasBeenSet; }
  template <typename DBSubnetGroupT = Aws::String>
  void SetDBSubnetGroup(DBSubnetGroupT&& value) {
    m_dBSubnetGroupHasBeenSet = true;
    m_dBSubnetGroup = std::forward<DBSubnetGroupT>(value);
  }
  template <typename DBSubnetGroupT = Aws::String>
  DBCluster& WithDBSubnetGroup(DBSubnetGroupT&& value) {
    SetDBSubnetGroup(std::forward<DBSubnetGroupT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetStatus() const { return m_status; }
  inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
  template <typename StatusT = Aws::String>
  void SetStatus(StatusT&& value) {
    m_statusHasBeenSet = true;
    m_status = std::forward<StatusT>(value);
  }
  template <typename StatusT = Aws::String>
  DBCluster& WithStatus(StatusT&& value) {
    SetStatus(std::forward<StatusT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPercentProgress() const { return m_percentProgress; }
  inline bool PercentProgressHasBeenSet() const { return m_percentProgressHasBeenSet; }
  template <typename PercentProgressT = Aws::String>
  void SetPercentProgress(PercentProgressT&& value) {
    m_percentProgressHasBeenSet = true;
    m_percentProgress = std::forward<PercentProgressT>(value);
  }
  template <typename PercentProgressT = Aws::String>
  DBCluster& WithPercentProgress(PercentProgressT&& value) {
    SetPercentProgress(std::forward<PercentProgressT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetEarliestRestorableTime() const { return m_earliestRestorableTime; }
  inline bool EarliestRestorableTimeHasBeenSet() const { return m_earliestRestorableTimeHasBeenSet; }
  template <typename EarliestRestorableTimeT = Aws::Utils::DateTime>
  void SetEarliestRestorableTime(EarliestRestorableTimeT&& value) {
    m_earliestRestorableTimeHasBeenSet = true;
    m_earliestRestorableTime = std::forward<EarliestRestorableTimeT>(value);
  }
  template <typename EarliestRestorableTimeT = Aws::Utils::DateTime>
  DBCluster& WithEarliestRestorableTime(EarliestRestorableTimeT&& value) {
    SetEarliestRestorableTime(std::forward<EarliestRestorableTimeT>(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>
  DBCluster& WithEndpoint(EndpointT&& value) {
    SetEndpoint(std::forward<EndpointT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetReaderEndpoint() const { return m_readerEndpoint; }
  inline bool ReaderEndpointHasBeenSet() const { return m_readerEndpointHasBeenSet; }
  template <typename ReaderEndpointT = Aws::String>
  void SetReaderEndpoint(ReaderEndpointT&& value) {
    m_readerEndpointHasBeenSet = true;
    m_readerEndpoint = std::forward<ReaderEndpointT>(value);
  }
  template <typename ReaderEndpointT = Aws::String>
  DBCluster& WithReaderEndpoint(ReaderEndpointT&& value) {
    SetReaderEndpoint(std::forward<ReaderEndpointT>(value));
    return *this;
  }
 
 
  inline bool GetMultiAZ() const { return m_multiAZ; }
  inline bool MultiAZHasBeenSet() const { return m_multiAZHasBeenSet; }
  inline void SetMultiAZ(bool value) {
    m_multiAZHasBeenSet = true;
    m_multiAZ = value;
  }
  inline DBCluster& WithMultiAZ(bool value) {
    SetMultiAZ(value);
    return *this;
  }
 
 
  inline const Aws::String& GetEngine() const { return m_engine; }
  inline bool EngineHasBeenSet() const { return m_engineHasBeenSet; }
  template <typename EngineT = Aws::String>
  void SetEngine(EngineT&& value) {
    m_engineHasBeenSet = true;
    m_engine = std::forward<EngineT>(value);
  }
  template <typename EngineT = Aws::String>
  DBCluster& WithEngine(EngineT&& value) {
    SetEngine(std::forward<EngineT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetEngineVersion() const { return m_engineVersion; }
  inline bool EngineVersionHasBeenSet() const { return m_engineVersionHasBeenSet; }
  template <typename EngineVersionT = Aws::String>
  void SetEngineVersion(EngineVersionT&& value) {
    m_engineVersionHasBeenSet = true;
    m_engineVersion = std::forward<EngineVersionT>(value);
  }
  template <typename EngineVersionT = Aws::String>
  DBCluster& WithEngineVersion(EngineVersionT&& value) {
    SetEngineVersion(std::forward<EngineVersionT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetLatestRestorableTime() const { return m_latestRestorableTime; }
  inline bool LatestRestorableTimeHasBeenSet() const { return m_latestRestorableTimeHasBeenSet; }
  template <typename LatestRestorableTimeT = Aws::Utils::DateTime>
  void SetLatestRestorableTime(LatestRestorableTimeT&& value) {
    m_latestRestorableTimeHasBeenSet = true;
    m_latestRestorableTime = std::forward<LatestRestorableTimeT>(value);
  }
  template <typename LatestRestorableTimeT = Aws::Utils::DateTime>
  DBCluster& WithLatestRestorableTime(LatestRestorableTimeT&& value) {
    SetLatestRestorableTime(std::forward<LatestRestorableTimeT>(value));
    return *this;
  }
 
 
  inline int GetPort() const { return m_port; }
  inline bool PortHasBeenSet() const { return m_portHasBeenSet; }
  inline void SetPort(int value) {
    m_portHasBeenSet = true;
    m_port = value;
  }
  inline DBCluster& WithPort(int value) {
    SetPort(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>
  DBCluster& WithMasterUsername(MasterUsernameT&& value) {
    SetMasterUsername(std::forward<MasterUsernameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPreferredBackupWindow() const { return m_preferredBackupWindow; }
  inline bool PreferredBackupWindowHasBeenSet() const { return m_preferredBackupWindowHasBeenSet; }
  template <typename PreferredBackupWindowT = Aws::String>
  void SetPreferredBackupWindow(PreferredBackupWindowT&& value) {
    m_preferredBackupWindowHasBeenSet = true;
    m_preferredBackupWindow = std::forward<PreferredBackupWindowT>(value);
  }
  template <typename PreferredBackupWindowT = Aws::String>
  DBCluster& WithPreferredBackupWindow(PreferredBackupWindowT&& value) {
    SetPreferredBackupWindow(std::forward<PreferredBackupWindowT>(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>
  DBCluster& WithPreferredMaintenanceWindow(PreferredMaintenanceWindowT&& value) {
    SetPreferredMaintenanceWindow(std::forward<PreferredMaintenanceWindowT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetReplicationSourceIdentifier() const { return m_replicationSourceIdentifier; }
  inline bool ReplicationSourceIdentifierHasBeenSet() const { return m_replicationSourceIdentifierHasBeenSet; }
  template <typename ReplicationSourceIdentifierT = Aws::String>
  void SetReplicationSourceIdentifier(ReplicationSourceIdentifierT&& value) {
    m_replicationSourceIdentifierHasBeenSet = true;
    m_replicationSourceIdentifier = std::forward<ReplicationSourceIdentifierT>(value);
  }
  template <typename ReplicationSourceIdentifierT = Aws::String>
  DBCluster& WithReplicationSourceIdentifier(ReplicationSourceIdentifierT&& value) {
    SetReplicationSourceIdentifier(std::forward<ReplicationSourceIdentifierT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetReadReplicaIdentifiers() const { return m_readReplicaIdentifiers; }
  inline bool ReadReplicaIdentifiersHasBeenSet() const { return m_readReplicaIdentifiersHasBeenSet; }
  template <typename ReadReplicaIdentifiersT = Aws::Vector<Aws::String>>
  void SetReadReplicaIdentifiers(ReadReplicaIdentifiersT&& value) {
    m_readReplicaIdentifiersHasBeenSet = true;
    m_readReplicaIdentifiers = std::forward<ReadReplicaIdentifiersT>(value);
  }
  template <typename ReadReplicaIdentifiersT = Aws::Vector<Aws::String>>
  DBCluster& WithReadReplicaIdentifiers(ReadReplicaIdentifiersT&& value) {
    SetReadReplicaIdentifiers(std::forward<ReadReplicaIdentifiersT>(value));
    return *this;
  }
  template <typename ReadReplicaIdentifiersT = Aws::String>
  DBCluster& AddReadReplicaIdentifiers(ReadReplicaIdentifiersT&& value) {
    m_readReplicaIdentifiersHasBeenSet = true;
    m_readReplicaIdentifiers.emplace_back(std::forward<ReadReplicaIdentifiersT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<DBClusterMember>& GetDBClusterMembers() const { return m_dBClusterMembers; }
  inline bool DBClusterMembersHasBeenSet() const { return m_dBClusterMembersHasBeenSet; }
  template <typename DBClusterMembersT = Aws::Vector<DBClusterMember>>
  void SetDBClusterMembers(DBClusterMembersT&& value) {
    m_dBClusterMembersHasBeenSet = true;
    m_dBClusterMembers = std::forward<DBClusterMembersT>(value);
  }
  template <typename DBClusterMembersT = Aws::Vector<DBClusterMember>>
  DBCluster& WithDBClusterMembers(DBClusterMembersT&& value) {
    SetDBClusterMembers(std::forward<DBClusterMembersT>(value));
    return *this;
  }
  template <typename DBClusterMembersT = DBClusterMember>
  DBCluster& AddDBClusterMembers(DBClusterMembersT&& value) {
    m_dBClusterMembersHasBeenSet = true;
    m_dBClusterMembers.emplace_back(std::forward<DBClusterMembersT>(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>>
  DBCluster& WithVpcSecurityGroups(VpcSecurityGroupsT&& value) {
    SetVpcSecurityGroups(std::forward<VpcSecurityGroupsT>(value));
    return *this;
  }
  template <typename VpcSecurityGroupsT = VpcSecurityGroupMembership>
  DBCluster& AddVpcSecurityGroups(VpcSecurityGroupsT&& value) {
    m_vpcSecurityGroupsHasBeenSet = true;
    m_vpcSecurityGroups.emplace_back(std::forward<VpcSecurityGroupsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetHostedZoneId() const { return m_hostedZoneId; }
  inline bool HostedZoneIdHasBeenSet() const { return m_hostedZoneIdHasBeenSet; }
  template <typename HostedZoneIdT = Aws::String>
  void SetHostedZoneId(HostedZoneIdT&& value) {
    m_hostedZoneIdHasBeenSet = true;
    m_hostedZoneId = std::forward<HostedZoneIdT>(value);
  }
  template <typename HostedZoneIdT = Aws::String>
  DBCluster& WithHostedZoneId(HostedZoneIdT&& value) {
    SetHostedZoneId(std::forward<HostedZoneIdT>(value));
    return *this;
  }
 
 
  inline bool GetStorageEncrypted() const { return m_storageEncrypted; }
  inline bool StorageEncryptedHasBeenSet() const { return m_storageEncryptedHasBeenSet; }
  inline void SetStorageEncrypted(bool value) {
    m_storageEncryptedHasBeenSet = true;
    m_storageEncrypted = value;
  }
  inline DBCluster& WithStorageEncrypted(bool value) {
    SetStorageEncrypted(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>
  DBCluster& WithKmsKeyId(KmsKeyIdT&& value) {
    SetKmsKeyId(std::forward<KmsKeyIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDbClusterResourceId() const { return m_dbClusterResourceId; }
  inline bool DbClusterResourceIdHasBeenSet() const { return m_dbClusterResourceIdHasBeenSet; }
  template <typename DbClusterResourceIdT = Aws::String>
  void SetDbClusterResourceId(DbClusterResourceIdT&& value) {
    m_dbClusterResourceIdHasBeenSet = true;
    m_dbClusterResourceId = std::forward<DbClusterResourceIdT>(value);
  }
  template <typename DbClusterResourceIdT = Aws::String>
  DBCluster& WithDbClusterResourceId(DbClusterResourceIdT&& value) {
    SetDbClusterResourceId(std::forward<DbClusterResourceIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDBClusterArn() const { return m_dBClusterArn; }
  inline bool DBClusterArnHasBeenSet() const { return m_dBClusterArnHasBeenSet; }
  template <typename DBClusterArnT = Aws::String>
  void SetDBClusterArn(DBClusterArnT&& value) {
    m_dBClusterArnHasBeenSet = true;
    m_dBClusterArn = std::forward<DBClusterArnT>(value);
  }
  template <typename DBClusterArnT = Aws::String>
  DBCluster& WithDBClusterArn(DBClusterArnT&& value) {
    SetDBClusterArn(std::forward<DBClusterArnT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<DBClusterRole>& GetAssociatedRoles() const { return m_associatedRoles; }
  inline bool AssociatedRolesHasBeenSet() const { return m_associatedRolesHasBeenSet; }
  template <typename AssociatedRolesT = Aws::Vector<DBClusterRole>>
  void SetAssociatedRoles(AssociatedRolesT&& value) {
    m_associatedRolesHasBeenSet = true;
    m_associatedRoles = std::forward<AssociatedRolesT>(value);
  }
  template <typename AssociatedRolesT = Aws::Vector<DBClusterRole>>
  DBCluster& WithAssociatedRoles(AssociatedRolesT&& value) {
    SetAssociatedRoles(std::forward<AssociatedRolesT>(value));
    return *this;
  }
  template <typename AssociatedRolesT = DBClusterRole>
  DBCluster& AddAssociatedRoles(AssociatedRolesT&& value) {
    m_associatedRolesHasBeenSet = true;
    m_associatedRoles.emplace_back(std::forward<AssociatedRolesT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCloneGroupId() const { return m_cloneGroupId; }
  inline bool CloneGroupIdHasBeenSet() const { return m_cloneGroupIdHasBeenSet; }
  template <typename CloneGroupIdT = Aws::String>
  void SetCloneGroupId(CloneGroupIdT&& value) {
    m_cloneGroupIdHasBeenSet = true;
    m_cloneGroupId = std::forward<CloneGroupIdT>(value);
  }
  template <typename CloneGroupIdT = Aws::String>
  DBCluster& WithCloneGroupId(CloneGroupIdT&& value) {
    SetCloneGroupId(std::forward<CloneGroupIdT>(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>
  DBCluster& WithClusterCreateTime(ClusterCreateTimeT&& value) {
    SetClusterCreateTime(std::forward<ClusterCreateTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetEnabledCloudwatchLogsExports() const { return m_enabledCloudwatchLogsExports; }
  inline bool EnabledCloudwatchLogsExportsHasBeenSet() const { return m_enabledCloudwatchLogsExportsHasBeenSet; }
  template <typename EnabledCloudwatchLogsExportsT = Aws::Vector<Aws::String>>
  void SetEnabledCloudwatchLogsExports(EnabledCloudwatchLogsExportsT&& value) {
    m_enabledCloudwatchLogsExportsHasBeenSet = true;
    m_enabledCloudwatchLogsExports = std::forward<EnabledCloudwatchLogsExportsT>(value);
  }
  template <typename EnabledCloudwatchLogsExportsT = Aws::Vector<Aws::String>>
  DBCluster& WithEnabledCloudwatchLogsExports(EnabledCloudwatchLogsExportsT&& value) {
    SetEnabledCloudwatchLogsExports(std::forward<EnabledCloudwatchLogsExportsT>(value));
    return *this;
  }
  template <typename EnabledCloudwatchLogsExportsT = Aws::String>
  DBCluster& AddEnabledCloudwatchLogsExports(EnabledCloudwatchLogsExportsT&& value) {
    m_enabledCloudwatchLogsExportsHasBeenSet = true;
    m_enabledCloudwatchLogsExports.emplace_back(std::forward<EnabledCloudwatchLogsExportsT>(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 DBCluster& WithDeletionProtection(bool value) {
    SetDeletionProtection(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetIOOptimizedNextAllowedModificationTime() const { return m_iOOptimizedNextAllowedModificationTime; }
  inline bool IOOptimizedNextAllowedModificationTimeHasBeenSet() const { return m_iOOptimizedNextAllowedModificationTimeHasBeenSet; }
  template <typename IOOptimizedNextAllowedModificationTimeT = Aws::Utils::DateTime>
  void SetIOOptimizedNextAllowedModificationTime(IOOptimizedNextAllowedModificationTimeT&& value) {
    m_iOOptimizedNextAllowedModificationTimeHasBeenSet = true;
    m_iOOptimizedNextAllowedModificationTime = std::forward<IOOptimizedNextAllowedModificationTimeT>(value);
  }
  template <typename IOOptimizedNextAllowedModificationTimeT = Aws::Utils::DateTime>
  DBCluster& WithIOOptimizedNextAllowedModificationTime(IOOptimizedNextAllowedModificationTimeT&& value) {
    SetIOOptimizedNextAllowedModificationTime(std::forward<IOOptimizedNextAllowedModificationTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetStorageType() const { return m_storageType; }
  inline bool StorageTypeHasBeenSet() const { return m_storageTypeHasBeenSet; }
  template <typename StorageTypeT = Aws::String>
  void SetStorageType(StorageTypeT&& value) {
    m_storageTypeHasBeenSet = true;
    m_storageType = std::forward<StorageTypeT>(value);
  }
  template <typename StorageTypeT = Aws::String>
  DBCluster& WithStorageType(StorageTypeT&& value) {
    SetStorageType(std::forward<StorageTypeT>(value));
    return *this;
  }
 
 
  inline const ServerlessV2ScalingConfigurationInfo& GetServerlessV2ScalingConfiguration() const {
    return m_serverlessV2ScalingConfiguration;
  }
  inline bool ServerlessV2ScalingConfigurationHasBeenSet() const { return m_serverlessV2ScalingConfigurationHasBeenSet; }
  template <typename ServerlessV2ScalingConfigurationT = ServerlessV2ScalingConfigurationInfo>
  void SetServerlessV2ScalingConfiguration(ServerlessV2ScalingConfigurationT&& value) {
    m_serverlessV2ScalingConfigurationHasBeenSet = true;
    m_serverlessV2ScalingConfiguration = std::forward<ServerlessV2ScalingConfigurationT>(value);
  }
  template <typename ServerlessV2ScalingConfigurationT = ServerlessV2ScalingConfigurationInfo>
  DBCluster& WithServerlessV2ScalingConfiguration(ServerlessV2ScalingConfigurationT&& value) {
    SetServerlessV2ScalingConfiguration(std::forward<ServerlessV2ScalingConfigurationT>(value));
    return *this;
  }
 
 
  inline const ClusterMasterUserSecret& GetMasterUserSecret() const { return m_masterUserSecret; }
  inline bool MasterUserSecretHasBeenSet() const { return m_masterUserSecretHasBeenSet; }
  template <typename MasterUserSecretT = ClusterMasterUserSecret>
  void SetMasterUserSecret(MasterUserSecretT&& value) {
    m_masterUserSecretHasBeenSet = true;
    m_masterUserSecret = std::forward<MasterUserSecretT>(value);
  }
  template <typename MasterUserSecretT = ClusterMasterUserSecret>
  DBCluster& WithMasterUserSecret(MasterUserSecretT&& value) {
    SetMasterUserSecret(std::forward<MasterUserSecretT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetNetworkType() const { return m_networkType; }
  inline bool NetworkTypeHasBeenSet() const { return m_networkTypeHasBeenSet; }
  template <typename NetworkTypeT = Aws::String>
  void SetNetworkType(NetworkTypeT&& value) {
    m_networkTypeHasBeenSet = true;
    m_networkType = std::forward<NetworkTypeT>(value);
  }
  template <typename NetworkTypeT = Aws::String>
  DBCluster& WithNetworkType(NetworkTypeT&& value) {
    SetNetworkType(std::forward<NetworkTypeT>(value));
    return *this;
  }
 private:
  Aws::Vector<Aws::String> m_availabilityZones;
 
  int m_backupRetentionPeriod{0};
 
  Aws::String m_dBClusterIdentifier;
 
  Aws::String m_dBClusterParameterGroup;
 
  Aws::String m_dBSubnetGroup;
 
  Aws::String m_status;
 
  Aws::String m_percentProgress;
 
  Aws::Utils::DateTime m_earliestRestorableTime{};
 
  Aws::String m_endpoint;
 
  Aws::String m_readerEndpoint;
 
  bool m_multiAZ{false};
 
  Aws::String m_engine;
 
  Aws::String m_engineVersion;
 
  Aws::Utils::DateTime m_latestRestorableTime{};
 
  int m_port{0};
 
  Aws::String m_masterUsername;
 
  Aws::String m_preferredBackupWindow;
 
  Aws::String m_preferredMaintenanceWindow;
 
  Aws::String m_replicationSourceIdentifier;
 
  Aws::Vector<Aws::String> m_readReplicaIdentifiers;
 
  Aws::Vector<DBClusterMember> m_dBClusterMembers;
 
  Aws::Vector<VpcSecurityGroupMembership> m_vpcSecurityGroups;
 
  Aws::String m_hostedZoneId;
 
  bool m_storageEncrypted{false};
 
  Aws::String m_kmsKeyId;
 
  Aws::String m_dbClusterResourceId;
 
  Aws::String m_dBClusterArn;
 
  Aws::Vector<DBClusterRole> m_associatedRoles;
 
  Aws::String m_cloneGroupId;
 
  Aws::Utils::DateTime m_clusterCreateTime{};
 
  Aws::Vector<Aws::String> m_enabledCloudwatchLogsExports;
 
  bool m_deletionProtection{false};
 
  Aws::Utils::DateTime m_iOOptimizedNextAllowedModificationTime{};
 
  Aws::String m_storageType;
 
  ServerlessV2ScalingConfigurationInfo m_serverlessV2ScalingConfiguration;
 
  ClusterMasterUserSecret m_masterUserSecret;
 
  Aws::String m_networkType;
  bool m_availabilityZonesHasBeenSet = false;
  bool m_backupRetentionPeriodHasBeenSet = false;
  bool m_dBClusterIdentifierHasBeenSet = false;
  bool m_dBClusterParameterGroupHasBeenSet = false;
  bool m_dBSubnetGroupHasBeenSet = false;
  bool m_statusHasBeenSet = false;
  bool m_percentProgressHasBeenSet = false;
  bool m_earliestRestorableTimeHasBeenSet = false;
  bool m_endpointHasBeenSet = false;
  bool m_readerEndpointHasBeenSet = false;
  bool m_multiAZHasBeenSet = false;
  bool m_engineHasBeenSet = false;
  bool m_engineVersionHasBeenSet = false;
  bool m_latestRestorableTimeHasBeenSet = false;
  bool m_portHasBeenSet = false;
  bool m_masterUsernameHasBeenSet = false;
  bool m_preferredBackupWindowHasBeenSet = false;
  bool m_preferredMaintenanceWindowHasBeenSet = false;
  bool m_replicationSourceIdentifierHasBeenSet = false;
  bool m_readReplicaIdentifiersHasBeenSet = false;
  bool m_dBClusterMembersHasBeenSet = false;
  bool m_vpcSecurityGroupsHasBeenSet = false;
  bool m_hostedZoneIdHasBeenSet = false;
  bool m_storageEncryptedHasBeenSet = false;
  bool m_kmsKeyIdHasBeenSet = false;
  bool m_dbClusterResourceIdHasBeenSet = false;
  bool m_dBClusterArnHasBeenSet = false;
  bool m_associatedRolesHasBeenSet = false;
  bool m_cloneGroupIdHasBeenSet = false;
  bool m_clusterCreateTimeHasBeenSet = false;
  bool m_enabledCloudwatchLogsExportsHasBeenSet = false;
  bool m_deletionProtectionHasBeenSet = false;
  bool m_iOOptimizedNextAllowedModificationTimeHasBeenSet = false;
  bool m_storageTypeHasBeenSet = false;
  bool m_serverlessV2ScalingConfigurationHasBeenSet = false;
  bool m_masterUserSecretHasBeenSet = false;
  bool m_networkTypeHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace DocDB
}  // namespace Aws