ReplicationGroup.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/elasticache/ElastiCache_EXPORTS.h>
#include <aws/elasticache/model/AutomaticFailoverStatus.h>
#include <aws/elasticache/model/ClusterMode.h>
#include <aws/elasticache/model/DataTieringStatus.h>
#include <aws/elasticache/model/Durability.h>
#include <aws/elasticache/model/EffectiveDurability.h>
#include <aws/elasticache/model/Endpoint.h>
#include <aws/elasticache/model/GlobalReplicationGroupInfo.h>
#include <aws/elasticache/model/IpDiscovery.h>
#include <aws/elasticache/model/LogDeliveryConfiguration.h>
#include <aws/elasticache/model/MultiAZStatus.h>
#include <aws/elasticache/model/NetworkType.h>
#include <aws/elasticache/model/NodeGroup.h>
#include <aws/elasticache/model/ReplicationGroupPendingModifiedValues.h>
#include <aws/elasticache/model/StorageEncryptionType.h>
#include <aws/elasticache/model/TransitEncryptionMode.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Xml {
class XmlNode;
}  // namespace Xml
}  // namespace Utils
namespace ElastiCache {
namespace Model {
 
class ReplicationGroup {
 public:
  AWS_ELASTICACHE_API ReplicationGroup() = default;
  AWS_ELASTICACHE_API ReplicationGroup(const Aws::Utils::Xml::XmlNode& xmlNode);
  AWS_ELASTICACHE_API ReplicationGroup& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
 
  AWS_ELASTICACHE_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
  AWS_ELASTICACHE_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
 
 
  inline const Aws::String& GetReplicationGroupId() const { return m_replicationGroupId; }
  inline bool ReplicationGroupIdHasBeenSet() const { return m_replicationGroupIdHasBeenSet; }
  template <typename ReplicationGroupIdT = Aws::String>
  void SetReplicationGroupId(ReplicationGroupIdT&& value) {
    m_replicationGroupIdHasBeenSet = true;
    m_replicationGroupId = std::forward<ReplicationGroupIdT>(value);
  }
  template <typename ReplicationGroupIdT = Aws::String>
  ReplicationGroup& WithReplicationGroupId(ReplicationGroupIdT&& value) {
    SetReplicationGroupId(std::forward<ReplicationGroupIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDescription() const { return m_description; }
  inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
  template <typename DescriptionT = Aws::String>
  void SetDescription(DescriptionT&& value) {
    m_descriptionHasBeenSet = true;
    m_description = std::forward<DescriptionT>(value);
  }
  template <typename DescriptionT = Aws::String>
  ReplicationGroup& WithDescription(DescriptionT&& value) {
    SetDescription(std::forward<DescriptionT>(value));
    return *this;
  }
 
 
  inline const GlobalReplicationGroupInfo& GetGlobalReplicationGroupInfo() const { return m_globalReplicationGroupInfo; }
  inline bool GlobalReplicationGroupInfoHasBeenSet() const { return m_globalReplicationGroupInfoHasBeenSet; }
  template <typename GlobalReplicationGroupInfoT = GlobalReplicationGroupInfo>
  void SetGlobalReplicationGroupInfo(GlobalReplicationGroupInfoT&& value) {
    m_globalReplicationGroupInfoHasBeenSet = true;
    m_globalReplicationGroupInfo = std::forward<GlobalReplicationGroupInfoT>(value);
  }
  template <typename GlobalReplicationGroupInfoT = GlobalReplicationGroupInfo>
  ReplicationGroup& WithGlobalReplicationGroupInfo(GlobalReplicationGroupInfoT&& value) {
    SetGlobalReplicationGroupInfo(std::forward<GlobalReplicationGroupInfoT>(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>
  ReplicationGroup& WithStatus(StatusT&& value) {
    SetStatus(std::forward<StatusT>(value));
    return *this;
  }
 
 
  inline const ReplicationGroupPendingModifiedValues& GetPendingModifiedValues() const { return m_pendingModifiedValues; }
  inline bool PendingModifiedValuesHasBeenSet() const { return m_pendingModifiedValuesHasBeenSet; }
  template <typename PendingModifiedValuesT = ReplicationGroupPendingModifiedValues>
  void SetPendingModifiedValues(PendingModifiedValuesT&& value) {
    m_pendingModifiedValuesHasBeenSet = true;
    m_pendingModifiedValues = std::forward<PendingModifiedValuesT>(value);
  }
  template <typename PendingModifiedValuesT = ReplicationGroupPendingModifiedValues>
  ReplicationGroup& WithPendingModifiedValues(PendingModifiedValuesT&& value) {
    SetPendingModifiedValues(std::forward<PendingModifiedValuesT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetMemberClusters() const { return m_memberClusters; }
  inline bool MemberClustersHasBeenSet() const { return m_memberClustersHasBeenSet; }
  template <typename MemberClustersT = Aws::Vector<Aws::String>>
  void SetMemberClusters(MemberClustersT&& value) {
    m_memberClustersHasBeenSet = true;
    m_memberClusters = std::forward<MemberClustersT>(value);
  }
  template <typename MemberClustersT = Aws::Vector<Aws::String>>
  ReplicationGroup& WithMemberClusters(MemberClustersT&& value) {
    SetMemberClusters(std::forward<MemberClustersT>(value));
    return *this;
  }
  template <typename MemberClustersT = Aws::String>
  ReplicationGroup& AddMemberClusters(MemberClustersT&& value) {
    m_memberClustersHasBeenSet = true;
    m_memberClusters.emplace_back(std::forward<MemberClustersT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<NodeGroup>& GetNodeGroups() const { return m_nodeGroups; }
  inline bool NodeGroupsHasBeenSet() const { return m_nodeGroupsHasBeenSet; }
  template <typename NodeGroupsT = Aws::Vector<NodeGroup>>
  void SetNodeGroups(NodeGroupsT&& value) {
    m_nodeGroupsHasBeenSet = true;
    m_nodeGroups = std::forward<NodeGroupsT>(value);
  }
  template <typename NodeGroupsT = Aws::Vector<NodeGroup>>
  ReplicationGroup& WithNodeGroups(NodeGroupsT&& value) {
    SetNodeGroups(std::forward<NodeGroupsT>(value));
    return *this;
  }
  template <typename NodeGroupsT = NodeGroup>
  ReplicationGroup& AddNodeGroups(NodeGroupsT&& value) {
    m_nodeGroupsHasBeenSet = true;
    m_nodeGroups.emplace_back(std::forward<NodeGroupsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSnapshottingClusterId() const { return m_snapshottingClusterId; }
  inline bool SnapshottingClusterIdHasBeenSet() const { return m_snapshottingClusterIdHasBeenSet; }
  template <typename SnapshottingClusterIdT = Aws::String>
  void SetSnapshottingClusterId(SnapshottingClusterIdT&& value) {
    m_snapshottingClusterIdHasBeenSet = true;
    m_snapshottingClusterId = std::forward<SnapshottingClusterIdT>(value);
  }
  template <typename SnapshottingClusterIdT = Aws::String>
  ReplicationGroup& WithSnapshottingClusterId(SnapshottingClusterIdT&& value) {
    SetSnapshottingClusterId(std::forward<SnapshottingClusterIdT>(value));
    return *this;
  }
 
 
  inline AutomaticFailoverStatus GetAutomaticFailover() const { return m_automaticFailover; }
  inline bool AutomaticFailoverHasBeenSet() const { return m_automaticFailoverHasBeenSet; }
  inline void SetAutomaticFailover(AutomaticFailoverStatus value) {
    m_automaticFailoverHasBeenSet = true;
    m_automaticFailover = value;
  }
  inline ReplicationGroup& WithAutomaticFailover(AutomaticFailoverStatus value) {
    SetAutomaticFailover(value);
    return *this;
  }
 
 
  inline MultiAZStatus GetMultiAZ() const { return m_multiAZ; }
  inline bool MultiAZHasBeenSet() const { return m_multiAZHasBeenSet; }
  inline void SetMultiAZ(MultiAZStatus value) {
    m_multiAZHasBeenSet = true;
    m_multiAZ = value;
  }
  inline ReplicationGroup& WithMultiAZ(MultiAZStatus value) {
    SetMultiAZ(value);
    return *this;
  }
 
 
  inline const Endpoint& GetConfigurationEndpoint() const { return m_configurationEndpoint; }
  inline bool ConfigurationEndpointHasBeenSet() const { return m_configurationEndpointHasBeenSet; }
  template <typename ConfigurationEndpointT = Endpoint>
  void SetConfigurationEndpoint(ConfigurationEndpointT&& value) {
    m_configurationEndpointHasBeenSet = true;
    m_configurationEndpoint = std::forward<ConfigurationEndpointT>(value);
  }
  template <typename ConfigurationEndpointT = Endpoint>
  ReplicationGroup& WithConfigurationEndpoint(ConfigurationEndpointT&& value) {
    SetConfigurationEndpoint(std::forward<ConfigurationEndpointT>(value));
    return *this;
  }
 
 
  inline int GetSnapshotRetentionLimit() const { return m_snapshotRetentionLimit; }
  inline bool SnapshotRetentionLimitHasBeenSet() const { return m_snapshotRetentionLimitHasBeenSet; }
  inline void SetSnapshotRetentionLimit(int value) {
    m_snapshotRetentionLimitHasBeenSet = true;
    m_snapshotRetentionLimit = value;
  }
  inline ReplicationGroup& WithSnapshotRetentionLimit(int value) {
    SetSnapshotRetentionLimit(value);
    return *this;
  }
 
 
  inline const Aws::String& GetSnapshotWindow() const { return m_snapshotWindow; }
  inline bool SnapshotWindowHasBeenSet() const { return m_snapshotWindowHasBeenSet; }
  template <typename SnapshotWindowT = Aws::String>
  void SetSnapshotWindow(SnapshotWindowT&& value) {
    m_snapshotWindowHasBeenSet = true;
    m_snapshotWindow = std::forward<SnapshotWindowT>(value);
  }
  template <typename SnapshotWindowT = Aws::String>
  ReplicationGroup& WithSnapshotWindow(SnapshotWindowT&& value) {
    SetSnapshotWindow(std::forward<SnapshotWindowT>(value));
    return *this;
  }
 
 
  inline bool GetClusterEnabled() const { return m_clusterEnabled; }
  inline bool ClusterEnabledHasBeenSet() const { return m_clusterEnabledHasBeenSet; }
  inline void SetClusterEnabled(bool value) {
    m_clusterEnabledHasBeenSet = true;
    m_clusterEnabled = value;
  }
  inline ReplicationGroup& WithClusterEnabled(bool value) {
    SetClusterEnabled(value);
    return *this;
  }
 
 
  inline const Aws::String& GetCacheNodeType() const { return m_cacheNodeType; }
  inline bool CacheNodeTypeHasBeenSet() const { return m_cacheNodeTypeHasBeenSet; }
  template <typename CacheNodeTypeT = Aws::String>
  void SetCacheNodeType(CacheNodeTypeT&& value) {
    m_cacheNodeTypeHasBeenSet = true;
    m_cacheNodeType = std::forward<CacheNodeTypeT>(value);
  }
  template <typename CacheNodeTypeT = Aws::String>
  ReplicationGroup& WithCacheNodeType(CacheNodeTypeT&& value) {
    SetCacheNodeType(std::forward<CacheNodeTypeT>(value));
    return *this;
  }
 
 
  inline bool GetAuthTokenEnabled() const { return m_authTokenEnabled; }
  inline bool AuthTokenEnabledHasBeenSet() const { return m_authTokenEnabledHasBeenSet; }
  inline void SetAuthTokenEnabled(bool value) {
    m_authTokenEnabledHasBeenSet = true;
    m_authTokenEnabled = value;
  }
  inline ReplicationGroup& WithAuthTokenEnabled(bool value) {
    SetAuthTokenEnabled(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetAuthTokenLastModifiedDate() const { return m_authTokenLastModifiedDate; }
  inline bool AuthTokenLastModifiedDateHasBeenSet() const { return m_authTokenLastModifiedDateHasBeenSet; }
  template <typename AuthTokenLastModifiedDateT = Aws::Utils::DateTime>
  void SetAuthTokenLastModifiedDate(AuthTokenLastModifiedDateT&& value) {
    m_authTokenLastModifiedDateHasBeenSet = true;
    m_authTokenLastModifiedDate = std::forward<AuthTokenLastModifiedDateT>(value);
  }
  template <typename AuthTokenLastModifiedDateT = Aws::Utils::DateTime>
  ReplicationGroup& WithAuthTokenLastModifiedDate(AuthTokenLastModifiedDateT&& value) {
    SetAuthTokenLastModifiedDate(std::forward<AuthTokenLastModifiedDateT>(value));
    return *this;
  }
 
 
  inline bool GetTransitEncryptionEnabled() const { return m_transitEncryptionEnabled; }
  inline bool TransitEncryptionEnabledHasBeenSet() const { return m_transitEncryptionEnabledHasBeenSet; }
  inline void SetTransitEncryptionEnabled(bool value) {
    m_transitEncryptionEnabledHasBeenSet = true;
    m_transitEncryptionEnabled = value;
  }
  inline ReplicationGroup& WithTransitEncryptionEnabled(bool value) {
    SetTransitEncryptionEnabled(value);
    return *this;
  }
 
 
  inline bool GetAtRestEncryptionEnabled() const { return m_atRestEncryptionEnabled; }
  inline bool AtRestEncryptionEnabledHasBeenSet() const { return m_atRestEncryptionEnabledHasBeenSet; }
  inline void SetAtRestEncryptionEnabled(bool value) {
    m_atRestEncryptionEnabledHasBeenSet = true;
    m_atRestEncryptionEnabled = value;
  }
  inline ReplicationGroup& WithAtRestEncryptionEnabled(bool value) {
    SetAtRestEncryptionEnabled(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetMemberClustersOutpostArns() const { return m_memberClustersOutpostArns; }
  inline bool MemberClustersOutpostArnsHasBeenSet() const { return m_memberClustersOutpostArnsHasBeenSet; }
  template <typename MemberClustersOutpostArnsT = Aws::Vector<Aws::String>>
  void SetMemberClustersOutpostArns(MemberClustersOutpostArnsT&& value) {
    m_memberClustersOutpostArnsHasBeenSet = true;
    m_memberClustersOutpostArns = std::forward<MemberClustersOutpostArnsT>(value);
  }
  template <typename MemberClustersOutpostArnsT = Aws::Vector<Aws::String>>
  ReplicationGroup& WithMemberClustersOutpostArns(MemberClustersOutpostArnsT&& value) {
    SetMemberClustersOutpostArns(std::forward<MemberClustersOutpostArnsT>(value));
    return *this;
  }
  template <typename MemberClustersOutpostArnsT = Aws::String>
  ReplicationGroup& AddMemberClustersOutpostArns(MemberClustersOutpostArnsT&& value) {
    m_memberClustersOutpostArnsHasBeenSet = true;
    m_memberClustersOutpostArns.emplace_back(std::forward<MemberClustersOutpostArnsT>(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>
  ReplicationGroup& WithKmsKeyId(KmsKeyIdT&& value) {
    SetKmsKeyId(std::forward<KmsKeyIdT>(value));
    return *this;
  }
 
 
  inline StorageEncryptionType GetStorageEncryptionType() const { return m_storageEncryptionType; }
  inline bool StorageEncryptionTypeHasBeenSet() const { return m_storageEncryptionTypeHasBeenSet; }
  inline void SetStorageEncryptionType(StorageEncryptionType value) {
    m_storageEncryptionTypeHasBeenSet = true;
    m_storageEncryptionType = value;
  }
  inline ReplicationGroup& WithStorageEncryptionType(StorageEncryptionType value) {
    SetStorageEncryptionType(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>
  ReplicationGroup& WithARN(ARNT&& value) {
    SetARN(std::forward<ARNT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetUserGroupIds() const { return m_userGroupIds; }
  inline bool UserGroupIdsHasBeenSet() const { return m_userGroupIdsHasBeenSet; }
  template <typename UserGroupIdsT = Aws::Vector<Aws::String>>
  void SetUserGroupIds(UserGroupIdsT&& value) {
    m_userGroupIdsHasBeenSet = true;
    m_userGroupIds = std::forward<UserGroupIdsT>(value);
  }
  template <typename UserGroupIdsT = Aws::Vector<Aws::String>>
  ReplicationGroup& WithUserGroupIds(UserGroupIdsT&& value) {
    SetUserGroupIds(std::forward<UserGroupIdsT>(value));
    return *this;
  }
  template <typename UserGroupIdsT = Aws::String>
  ReplicationGroup& AddUserGroupIds(UserGroupIdsT&& value) {
    m_userGroupIdsHasBeenSet = true;
    m_userGroupIds.emplace_back(std::forward<UserGroupIdsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<LogDeliveryConfiguration>& GetLogDeliveryConfigurations() const { return m_logDeliveryConfigurations; }
  inline bool LogDeliveryConfigurationsHasBeenSet() const { return m_logDeliveryConfigurationsHasBeenSet; }
  template <typename LogDeliveryConfigurationsT = Aws::Vector<LogDeliveryConfiguration>>
  void SetLogDeliveryConfigurations(LogDeliveryConfigurationsT&& value) {
    m_logDeliveryConfigurationsHasBeenSet = true;
    m_logDeliveryConfigurations = std::forward<LogDeliveryConfigurationsT>(value);
  }
  template <typename LogDeliveryConfigurationsT = Aws::Vector<LogDeliveryConfiguration>>
  ReplicationGroup& WithLogDeliveryConfigurations(LogDeliveryConfigurationsT&& value) {
    SetLogDeliveryConfigurations(std::forward<LogDeliveryConfigurationsT>(value));
    return *this;
  }
  template <typename LogDeliveryConfigurationsT = LogDeliveryConfiguration>
  ReplicationGroup& AddLogDeliveryConfigurations(LogDeliveryConfigurationsT&& value) {
    m_logDeliveryConfigurationsHasBeenSet = true;
    m_logDeliveryConfigurations.emplace_back(std::forward<LogDeliveryConfigurationsT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetReplicationGroupCreateTime() const { return m_replicationGroupCreateTime; }
  inline bool ReplicationGroupCreateTimeHasBeenSet() const { return m_replicationGroupCreateTimeHasBeenSet; }
  template <typename ReplicationGroupCreateTimeT = Aws::Utils::DateTime>
  void SetReplicationGroupCreateTime(ReplicationGroupCreateTimeT&& value) {
    m_replicationGroupCreateTimeHasBeenSet = true;
    m_replicationGroupCreateTime = std::forward<ReplicationGroupCreateTimeT>(value);
  }
  template <typename ReplicationGroupCreateTimeT = Aws::Utils::DateTime>
  ReplicationGroup& WithReplicationGroupCreateTime(ReplicationGroupCreateTimeT&& value) {
    SetReplicationGroupCreateTime(std::forward<ReplicationGroupCreateTimeT>(value));
    return *this;
  }
 
 
  inline DataTieringStatus GetDataTiering() const { return m_dataTiering; }
  inline bool DataTieringHasBeenSet() const { return m_dataTieringHasBeenSet; }
  inline void SetDataTiering(DataTieringStatus value) {
    m_dataTieringHasBeenSet = true;
    m_dataTiering = value;
  }
  inline ReplicationGroup& WithDataTiering(DataTieringStatus value) {
    SetDataTiering(value);
    return *this;
  }
 
 
  inline bool GetAutoMinorVersionUpgrade() const { return m_autoMinorVersionUpgrade; }
  inline bool AutoMinorVersionUpgradeHasBeenSet() const { return m_autoMinorVersionUpgradeHasBeenSet; }
  inline void SetAutoMinorVersionUpgrade(bool value) {
    m_autoMinorVersionUpgradeHasBeenSet = true;
    m_autoMinorVersionUpgrade = value;
  }
  inline ReplicationGroup& WithAutoMinorVersionUpgrade(bool value) {
    SetAutoMinorVersionUpgrade(value);
    return *this;
  }
 
 
  inline NetworkType GetNetworkType() const { return m_networkType; }
  inline bool NetworkTypeHasBeenSet() const { return m_networkTypeHasBeenSet; }
  inline void SetNetworkType(NetworkType value) {
    m_networkTypeHasBeenSet = true;
    m_networkType = value;
  }
  inline ReplicationGroup& WithNetworkType(NetworkType value) {
    SetNetworkType(value);
    return *this;
  }
 
 
  inline IpDiscovery GetIpDiscovery() const { return m_ipDiscovery; }
  inline bool IpDiscoveryHasBeenSet() const { return m_ipDiscoveryHasBeenSet; }
  inline void SetIpDiscovery(IpDiscovery value) {
    m_ipDiscoveryHasBeenSet = true;
    m_ipDiscovery = value;
  }
  inline ReplicationGroup& WithIpDiscovery(IpDiscovery value) {
    SetIpDiscovery(value);
    return *this;
  }
 
 
  inline TransitEncryptionMode GetTransitEncryptionMode() const { return m_transitEncryptionMode; }
  inline bool TransitEncryptionModeHasBeenSet() const { return m_transitEncryptionModeHasBeenSet; }
  inline void SetTransitEncryptionMode(TransitEncryptionMode value) {
    m_transitEncryptionModeHasBeenSet = true;
    m_transitEncryptionMode = value;
  }
  inline ReplicationGroup& WithTransitEncryptionMode(TransitEncryptionMode value) {
    SetTransitEncryptionMode(value);
    return *this;
  }
 
 
  inline ClusterMode GetClusterMode() const { return m_clusterMode; }
  inline bool ClusterModeHasBeenSet() const { return m_clusterModeHasBeenSet; }
  inline void SetClusterMode(ClusterMode value) {
    m_clusterModeHasBeenSet = true;
    m_clusterMode = value;
  }
  inline ReplicationGroup& WithClusterMode(ClusterMode value) {
    SetClusterMode(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>
  ReplicationGroup& WithEngine(EngineT&& value) {
    SetEngine(std::forward<EngineT>(value));
    return *this;
  }
 
 
  inline Durability GetDurability() const { return m_durability; }
  inline bool DurabilityHasBeenSet() const { return m_durabilityHasBeenSet; }
  inline void SetDurability(Durability value) {
    m_durabilityHasBeenSet = true;
    m_durability = value;
  }
  inline ReplicationGroup& WithDurability(Durability value) {
    SetDurability(value);
    return *this;
  }
 
 
  inline EffectiveDurability GetEffectiveDurability() const { return m_effectiveDurability; }
  inline bool EffectiveDurabilityHasBeenSet() const { return m_effectiveDurabilityHasBeenSet; }
  inline void SetEffectiveDurability(EffectiveDurability value) {
    m_effectiveDurabilityHasBeenSet = true;
    m_effectiveDurability = value;
  }
  inline ReplicationGroup& WithEffectiveDurability(EffectiveDurability value) {
    SetEffectiveDurability(value);
    return *this;
  }
 private:
  Aws::String m_replicationGroupId;
 
  Aws::String m_description;
 
  GlobalReplicationGroupInfo m_globalReplicationGroupInfo;
 
  Aws::String m_status;
 
  ReplicationGroupPendingModifiedValues m_pendingModifiedValues;
 
  Aws::Vector<Aws::String> m_memberClusters;
 
  Aws::Vector<NodeGroup> m_nodeGroups;
 
  Aws::String m_snapshottingClusterId;
 
  AutomaticFailoverStatus m_automaticFailover{AutomaticFailoverStatus::NOT_SET};
 
  MultiAZStatus m_multiAZ{MultiAZStatus::NOT_SET};
 
  Endpoint m_configurationEndpoint;
 
  int m_snapshotRetentionLimit{0};
 
  Aws::String m_snapshotWindow;
 
  bool m_clusterEnabled{false};
 
  Aws::String m_cacheNodeType;
 
  bool m_authTokenEnabled{false};
 
  Aws::Utils::DateTime m_authTokenLastModifiedDate{};
 
  bool m_transitEncryptionEnabled{false};
 
  bool m_atRestEncryptionEnabled{false};
 
  Aws::Vector<Aws::String> m_memberClustersOutpostArns;
 
  Aws::String m_kmsKeyId;
 
  StorageEncryptionType m_storageEncryptionType{StorageEncryptionType::NOT_SET};
 
  Aws::String m_aRN;
 
  Aws::Vector<Aws::String> m_userGroupIds;
 
  Aws::Vector<LogDeliveryConfiguration> m_logDeliveryConfigurations;
 
  Aws::Utils::DateTime m_replicationGroupCreateTime{};
 
  DataTieringStatus m_dataTiering{DataTieringStatus::NOT_SET};
 
  bool m_autoMinorVersionUpgrade{false};
 
  NetworkType m_networkType{NetworkType::NOT_SET};
 
  IpDiscovery m_ipDiscovery{IpDiscovery::NOT_SET};
 
  TransitEncryptionMode m_transitEncryptionMode{TransitEncryptionMode::NOT_SET};
 
  ClusterMode m_clusterMode{ClusterMode::NOT_SET};
 
  Aws::String m_engine;
 
  Durability m_durability{Durability::NOT_SET};
 
  EffectiveDurability m_effectiveDurability{EffectiveDurability::NOT_SET};
  bool m_replicationGroupIdHasBeenSet = false;
  bool m_descriptionHasBeenSet = false;
  bool m_globalReplicationGroupInfoHasBeenSet = false;
  bool m_statusHasBeenSet = false;
  bool m_pendingModifiedValuesHasBeenSet = false;
  bool m_memberClustersHasBeenSet = false;
  bool m_nodeGroupsHasBeenSet = false;
  bool m_snapshottingClusterIdHasBeenSet = false;
  bool m_automaticFailoverHasBeenSet = false;
  bool m_multiAZHasBeenSet = false;
  bool m_configurationEndpointHasBeenSet = false;
  bool m_snapshotRetentionLimitHasBeenSet = false;
  bool m_snapshotWindowHasBeenSet = false;
  bool m_clusterEnabledHasBeenSet = false;
  bool m_cacheNodeTypeHasBeenSet = false;
  bool m_authTokenEnabledHasBeenSet = false;
  bool m_authTokenLastModifiedDateHasBeenSet = false;
  bool m_transitEncryptionEnabledHasBeenSet = false;
  bool m_atRestEncryptionEnabledHasBeenSet = false;
  bool m_memberClustersOutpostArnsHasBeenSet = false;
  bool m_kmsKeyIdHasBeenSet = false;
  bool m_storageEncryptionTypeHasBeenSet = false;
  bool m_aRNHasBeenSet = false;
  bool m_userGroupIdsHasBeenSet = false;
  bool m_logDeliveryConfigurationsHasBeenSet = false;
  bool m_replicationGroupCreateTimeHasBeenSet = false;
  bool m_dataTieringHasBeenSet = false;
  bool m_autoMinorVersionUpgradeHasBeenSet = false;
  bool m_networkTypeHasBeenSet = false;
  bool m_ipDiscoveryHasBeenSet = false;
  bool m_transitEncryptionModeHasBeenSet = false;
  bool m_clusterModeHasBeenSet = false;
  bool m_engineHasBeenSet = false;
  bool m_durabilityHasBeenSet = false;
  bool m_effectiveDurabilityHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace ElastiCache
}  // namespace Aws