CreateReplicationGroupRequest.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/elasticache/ElastiCacheRequest.h>
#include <aws/elasticache/ElastiCache_EXPORTS.h>
#include <aws/elasticache/model/ClusterMode.h>
#include <aws/elasticache/model/Durability.h>
#include <aws/elasticache/model/IpDiscovery.h>
#include <aws/elasticache/model/LogDeliveryConfigurationRequest.h>
#include <aws/elasticache/model/NetworkType.h>
#include <aws/elasticache/model/NodeGroupConfiguration.h>
#include <aws/elasticache/model/Tag.h>
#include <aws/elasticache/model/TransitEncryptionMode.h>
 
#include <utility>
 
namespace Aws {
namespace ElastiCache {
namespace Model {
 
class CreateReplicationGroupRequest : public ElastiCacheRequest {
 public:
  AWS_ELASTICACHE_API CreateReplicationGroupRequest() = default;
 
  // Service request name is the Operation name which will send this request out,
  // each operation should has unique request name, so that we can get operation's name from this request.
  // Note: this is not true for response, multiple operations may have the same response name,
  // so we can not get operation's name from response.
  inline virtual const char* GetServiceRequestName() const override { return "CreateReplicationGroup"; }
 
  AWS_ELASTICACHE_API Aws::String SerializePayload() const override;
 
 protected:
  AWS_ELASTICACHE_API void DumpBodyToUrl(Aws::Http::URI& uri) const override;
 
 public:
 
  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>
  CreateReplicationGroupRequest& WithReplicationGroupId(ReplicationGroupIdT&& value) {
    SetReplicationGroupId(std::forward<ReplicationGroupIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetReplicationGroupDescription() const { return m_replicationGroupDescription; }
  inline bool ReplicationGroupDescriptionHasBeenSet() const { return m_replicationGroupDescriptionHasBeenSet; }
  template <typename ReplicationGroupDescriptionT = Aws::String>
  void SetReplicationGroupDescription(ReplicationGroupDescriptionT&& value) {
    m_replicationGroupDescriptionHasBeenSet = true;
    m_replicationGroupDescription = std::forward<ReplicationGroupDescriptionT>(value);
  }
  template <typename ReplicationGroupDescriptionT = Aws::String>
  CreateReplicationGroupRequest& WithReplicationGroupDescription(ReplicationGroupDescriptionT&& value) {
    SetReplicationGroupDescription(std::forward<ReplicationGroupDescriptionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetGlobalReplicationGroupId() const { return m_globalReplicationGroupId; }
  inline bool GlobalReplicationGroupIdHasBeenSet() const { return m_globalReplicationGroupIdHasBeenSet; }
  template <typename GlobalReplicationGroupIdT = Aws::String>
  void SetGlobalReplicationGroupId(GlobalReplicationGroupIdT&& value) {
    m_globalReplicationGroupIdHasBeenSet = true;
    m_globalReplicationGroupId = std::forward<GlobalReplicationGroupIdT>(value);
  }
  template <typename GlobalReplicationGroupIdT = Aws::String>
  CreateReplicationGroupRequest& WithGlobalReplicationGroupId(GlobalReplicationGroupIdT&& value) {
    SetGlobalReplicationGroupId(std::forward<GlobalReplicationGroupIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPrimaryClusterId() const { return m_primaryClusterId; }
  inline bool PrimaryClusterIdHasBeenSet() const { return m_primaryClusterIdHasBeenSet; }
  template <typename PrimaryClusterIdT = Aws::String>
  void SetPrimaryClusterId(PrimaryClusterIdT&& value) {
    m_primaryClusterIdHasBeenSet = true;
    m_primaryClusterId = std::forward<PrimaryClusterIdT>(value);
  }
  template <typename PrimaryClusterIdT = Aws::String>
  CreateReplicationGroupRequest& WithPrimaryClusterId(PrimaryClusterIdT&& value) {
    SetPrimaryClusterId(std::forward<PrimaryClusterIdT>(value));
    return *this;
  }
 
 
  inline bool GetAutomaticFailoverEnabled() const { return m_automaticFailoverEnabled; }
  inline bool AutomaticFailoverEnabledHasBeenSet() const { return m_automaticFailoverEnabledHasBeenSet; }
  inline void SetAutomaticFailoverEnabled(bool value) {
    m_automaticFailoverEnabledHasBeenSet = true;
    m_automaticFailoverEnabled = value;
  }
  inline CreateReplicationGroupRequest& WithAutomaticFailoverEnabled(bool value) {
    SetAutomaticFailoverEnabled(value);
    return *this;
  }
 
 
  inline bool GetMultiAZEnabled() const { return m_multiAZEnabled; }
  inline bool MultiAZEnabledHasBeenSet() const { return m_multiAZEnabledHasBeenSet; }
  inline void SetMultiAZEnabled(bool value) {
    m_multiAZEnabledHasBeenSet = true;
    m_multiAZEnabled = value;
  }
  inline CreateReplicationGroupRequest& WithMultiAZEnabled(bool value) {
    SetMultiAZEnabled(value);
    return *this;
  }
 
 
  inline int GetNumCacheClusters() const { return m_numCacheClusters; }
  inline bool NumCacheClustersHasBeenSet() const { return m_numCacheClustersHasBeenSet; }
  inline void SetNumCacheClusters(int value) {
    m_numCacheClustersHasBeenSet = true;
    m_numCacheClusters = value;
  }
  inline CreateReplicationGroupRequest& WithNumCacheClusters(int value) {
    SetNumCacheClusters(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetPreferredCacheClusterAZs() const { return m_preferredCacheClusterAZs; }
  inline bool PreferredCacheClusterAZsHasBeenSet() const { return m_preferredCacheClusterAZsHasBeenSet; }
  template <typename PreferredCacheClusterAZsT = Aws::Vector<Aws::String>>
  void SetPreferredCacheClusterAZs(PreferredCacheClusterAZsT&& value) {
    m_preferredCacheClusterAZsHasBeenSet = true;
    m_preferredCacheClusterAZs = std::forward<PreferredCacheClusterAZsT>(value);
  }
  template <typename PreferredCacheClusterAZsT = Aws::Vector<Aws::String>>
  CreateReplicationGroupRequest& WithPreferredCacheClusterAZs(PreferredCacheClusterAZsT&& value) {
    SetPreferredCacheClusterAZs(std::forward<PreferredCacheClusterAZsT>(value));
    return *this;
  }
  template <typename PreferredCacheClusterAZsT = Aws::String>
  CreateReplicationGroupRequest& AddPreferredCacheClusterAZs(PreferredCacheClusterAZsT&& value) {
    m_preferredCacheClusterAZsHasBeenSet = true;
    m_preferredCacheClusterAZs.emplace_back(std::forward<PreferredCacheClusterAZsT>(value));
    return *this;
  }
 
 
  inline int GetNumNodeGroups() const { return m_numNodeGroups; }
  inline bool NumNodeGroupsHasBeenSet() const { return m_numNodeGroupsHasBeenSet; }
  inline void SetNumNodeGroups(int value) {
    m_numNodeGroupsHasBeenSet = true;
    m_numNodeGroups = value;
  }
  inline CreateReplicationGroupRequest& WithNumNodeGroups(int value) {
    SetNumNodeGroups(value);
    return *this;
  }
 
 
  inline int GetReplicasPerNodeGroup() const { return m_replicasPerNodeGroup; }
  inline bool ReplicasPerNodeGroupHasBeenSet() const { return m_replicasPerNodeGroupHasBeenSet; }
  inline void SetReplicasPerNodeGroup(int value) {
    m_replicasPerNodeGroupHasBeenSet = true;
    m_replicasPerNodeGroup = value;
  }
  inline CreateReplicationGroupRequest& WithReplicasPerNodeGroup(int value) {
    SetReplicasPerNodeGroup(value);
    return *this;
  }
 
 
  inline const Aws::Vector<NodeGroupConfiguration>& GetNodeGroupConfiguration() const { return m_nodeGroupConfiguration; }
  inline bool NodeGroupConfigurationHasBeenSet() const { return m_nodeGroupConfigurationHasBeenSet; }
  template <typename NodeGroupConfigurationT = Aws::Vector<NodeGroupConfiguration>>
  void SetNodeGroupConfiguration(NodeGroupConfigurationT&& value) {
    m_nodeGroupConfigurationHasBeenSet = true;
    m_nodeGroupConfiguration = std::forward<NodeGroupConfigurationT>(value);
  }
  template <typename NodeGroupConfigurationT = Aws::Vector<NodeGroupConfiguration>>
  CreateReplicationGroupRequest& WithNodeGroupConfiguration(NodeGroupConfigurationT&& value) {
    SetNodeGroupConfiguration(std::forward<NodeGroupConfigurationT>(value));
    return *this;
  }
  template <typename NodeGroupConfigurationT = NodeGroupConfiguration>
  CreateReplicationGroupRequest& AddNodeGroupConfiguration(NodeGroupConfigurationT&& value) {
    m_nodeGroupConfigurationHasBeenSet = true;
    m_nodeGroupConfiguration.emplace_back(std::forward<NodeGroupConfigurationT>(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>
  CreateReplicationGroupRequest& WithCacheNodeType(CacheNodeTypeT&& value) {
    SetCacheNodeType(std::forward<CacheNodeTypeT>(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>
  CreateReplicationGroupRequest& 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>
  CreateReplicationGroupRequest& WithEngineVersion(EngineVersionT&& value) {
    SetEngineVersion(std::forward<EngineVersionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCacheParameterGroupName() const { return m_cacheParameterGroupName; }
  inline bool CacheParameterGroupNameHasBeenSet() const { return m_cacheParameterGroupNameHasBeenSet; }
  template <typename CacheParameterGroupNameT = Aws::String>
  void SetCacheParameterGroupName(CacheParameterGroupNameT&& value) {
    m_cacheParameterGroupNameHasBeenSet = true;
    m_cacheParameterGroupName = std::forward<CacheParameterGroupNameT>(value);
  }
  template <typename CacheParameterGroupNameT = Aws::String>
  CreateReplicationGroupRequest& WithCacheParameterGroupName(CacheParameterGroupNameT&& value) {
    SetCacheParameterGroupName(std::forward<CacheParameterGroupNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCacheSubnetGroupName() const { return m_cacheSubnetGroupName; }
  inline bool CacheSubnetGroupNameHasBeenSet() const { return m_cacheSubnetGroupNameHasBeenSet; }
  template <typename CacheSubnetGroupNameT = Aws::String>
  void SetCacheSubnetGroupName(CacheSubnetGroupNameT&& value) {
    m_cacheSubnetGroupNameHasBeenSet = true;
    m_cacheSubnetGroupName = std::forward<CacheSubnetGroupNameT>(value);
  }
  template <typename CacheSubnetGroupNameT = Aws::String>
  CreateReplicationGroupRequest& WithCacheSubnetGroupName(CacheSubnetGroupNameT&& value) {
    SetCacheSubnetGroupName(std::forward<CacheSubnetGroupNameT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetCacheSecurityGroupNames() const { return m_cacheSecurityGroupNames; }
  inline bool CacheSecurityGroupNamesHasBeenSet() const { return m_cacheSecurityGroupNamesHasBeenSet; }
  template <typename CacheSecurityGroupNamesT = Aws::Vector<Aws::String>>
  void SetCacheSecurityGroupNames(CacheSecurityGroupNamesT&& value) {
    m_cacheSecurityGroupNamesHasBeenSet = true;
    m_cacheSecurityGroupNames = std::forward<CacheSecurityGroupNamesT>(value);
  }
  template <typename CacheSecurityGroupNamesT = Aws::Vector<Aws::String>>
  CreateReplicationGroupRequest& WithCacheSecurityGroupNames(CacheSecurityGroupNamesT&& value) {
    SetCacheSecurityGroupNames(std::forward<CacheSecurityGroupNamesT>(value));
    return *this;
  }
  template <typename CacheSecurityGroupNamesT = Aws::String>
  CreateReplicationGroupRequest& AddCacheSecurityGroupNames(CacheSecurityGroupNamesT&& value) {
    m_cacheSecurityGroupNamesHasBeenSet = true;
    m_cacheSecurityGroupNames.emplace_back(std::forward<CacheSecurityGroupNamesT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetSecurityGroupIds() const { return m_securityGroupIds; }
  inline bool SecurityGroupIdsHasBeenSet() const { return m_securityGroupIdsHasBeenSet; }
  template <typename SecurityGroupIdsT = Aws::Vector<Aws::String>>
  void SetSecurityGroupIds(SecurityGroupIdsT&& value) {
    m_securityGroupIdsHasBeenSet = true;
    m_securityGroupIds = std::forward<SecurityGroupIdsT>(value);
  }
  template <typename SecurityGroupIdsT = Aws::Vector<Aws::String>>
  CreateReplicationGroupRequest& WithSecurityGroupIds(SecurityGroupIdsT&& value) {
    SetSecurityGroupIds(std::forward<SecurityGroupIdsT>(value));
    return *this;
  }
  template <typename SecurityGroupIdsT = Aws::String>
  CreateReplicationGroupRequest& AddSecurityGroupIds(SecurityGroupIdsT&& value) {
    m_securityGroupIdsHasBeenSet = true;
    m_securityGroupIds.emplace_back(std::forward<SecurityGroupIdsT>(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>>
  CreateReplicationGroupRequest& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsT = Tag>
  CreateReplicationGroupRequest& AddTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace_back(std::forward<TagsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetSnapshotArns() const { return m_snapshotArns; }
  inline bool SnapshotArnsHasBeenSet() const { return m_snapshotArnsHasBeenSet; }
  template <typename SnapshotArnsT = Aws::Vector<Aws::String>>
  void SetSnapshotArns(SnapshotArnsT&& value) {
    m_snapshotArnsHasBeenSet = true;
    m_snapshotArns = std::forward<SnapshotArnsT>(value);
  }
  template <typename SnapshotArnsT = Aws::Vector<Aws::String>>
  CreateReplicationGroupRequest& WithSnapshotArns(SnapshotArnsT&& value) {
    SetSnapshotArns(std::forward<SnapshotArnsT>(value));
    return *this;
  }
  template <typename SnapshotArnsT = Aws::String>
  CreateReplicationGroupRequest& AddSnapshotArns(SnapshotArnsT&& value) {
    m_snapshotArnsHasBeenSet = true;
    m_snapshotArns.emplace_back(std::forward<SnapshotArnsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSnapshotName() const { return m_snapshotName; }
  inline bool SnapshotNameHasBeenSet() const { return m_snapshotNameHasBeenSet; }
  template <typename SnapshotNameT = Aws::String>
  void SetSnapshotName(SnapshotNameT&& value) {
    m_snapshotNameHasBeenSet = true;
    m_snapshotName = std::forward<SnapshotNameT>(value);
  }
  template <typename SnapshotNameT = Aws::String>
  CreateReplicationGroupRequest& WithSnapshotName(SnapshotNameT&& value) {
    SetSnapshotName(std::forward<SnapshotNameT>(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>
  CreateReplicationGroupRequest& WithPreferredMaintenanceWindow(PreferredMaintenanceWindowT&& value) {
    SetPreferredMaintenanceWindow(std::forward<PreferredMaintenanceWindowT>(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 CreateReplicationGroupRequest& WithPort(int value) {
    SetPort(value);
    return *this;
  }
 
 
  inline const Aws::String& GetNotificationTopicArn() const { return m_notificationTopicArn; }
  inline bool NotificationTopicArnHasBeenSet() const { return m_notificationTopicArnHasBeenSet; }
  template <typename NotificationTopicArnT = Aws::String>
  void SetNotificationTopicArn(NotificationTopicArnT&& value) {
    m_notificationTopicArnHasBeenSet = true;
    m_notificationTopicArn = std::forward<NotificationTopicArnT>(value);
  }
  template <typename NotificationTopicArnT = Aws::String>
  CreateReplicationGroupRequest& WithNotificationTopicArn(NotificationTopicArnT&& value) {
    SetNotificationTopicArn(std::forward<NotificationTopicArnT>(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 CreateReplicationGroupRequest& WithAutoMinorVersionUpgrade(bool value) {
    SetAutoMinorVersionUpgrade(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 CreateReplicationGroupRequest& 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>
  CreateReplicationGroupRequest& WithSnapshotWindow(SnapshotWindowT&& value) {
    SetSnapshotWindow(std::forward<SnapshotWindowT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAuthToken() const { return m_authToken; }
  inline bool AuthTokenHasBeenSet() const { return m_authTokenHasBeenSet; }
  template <typename AuthTokenT = Aws::String>
  void SetAuthToken(AuthTokenT&& value) {
    m_authTokenHasBeenSet = true;
    m_authToken = std::forward<AuthTokenT>(value);
  }
  template <typename AuthTokenT = Aws::String>
  CreateReplicationGroupRequest& WithAuthToken(AuthTokenT&& value) {
    SetAuthToken(std::forward<AuthTokenT>(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 CreateReplicationGroupRequest& 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 CreateReplicationGroupRequest& WithAtRestEncryptionEnabled(bool value) {
    SetAtRestEncryptionEnabled(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>
  CreateReplicationGroupRequest& WithKmsKeyId(KmsKeyIdT&& value) {
    SetKmsKeyId(std::forward<KmsKeyIdT>(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>>
  CreateReplicationGroupRequest& WithUserGroupIds(UserGroupIdsT&& value) {
    SetUserGroupIds(std::forward<UserGroupIdsT>(value));
    return *this;
  }
  template <typename UserGroupIdsT = Aws::String>
  CreateReplicationGroupRequest& AddUserGroupIds(UserGroupIdsT&& value) {
    m_userGroupIdsHasBeenSet = true;
    m_userGroupIds.emplace_back(std::forward<UserGroupIdsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<LogDeliveryConfigurationRequest>& GetLogDeliveryConfigurations() const { return m_logDeliveryConfigurations; }
  inline bool LogDeliveryConfigurationsHasBeenSet() const { return m_logDeliveryConfigurationsHasBeenSet; }
  template <typename LogDeliveryConfigurationsT = Aws::Vector<LogDeliveryConfigurationRequest>>
  void SetLogDeliveryConfigurations(LogDeliveryConfigurationsT&& value) {
    m_logDeliveryConfigurationsHasBeenSet = true;
    m_logDeliveryConfigurations = std::forward<LogDeliveryConfigurationsT>(value);
  }
  template <typename LogDeliveryConfigurationsT = Aws::Vector<LogDeliveryConfigurationRequest>>
  CreateReplicationGroupRequest& WithLogDeliveryConfigurations(LogDeliveryConfigurationsT&& value) {
    SetLogDeliveryConfigurations(std::forward<LogDeliveryConfigurationsT>(value));
    return *this;
  }
  template <typename LogDeliveryConfigurationsT = LogDeliveryConfigurationRequest>
  CreateReplicationGroupRequest& AddLogDeliveryConfigurations(LogDeliveryConfigurationsT&& value) {
    m_logDeliveryConfigurationsHasBeenSet = true;
    m_logDeliveryConfigurations.emplace_back(std::forward<LogDeliveryConfigurationsT>(value));
    return *this;
  }
 
 
  inline bool GetDataTieringEnabled() const { return m_dataTieringEnabled; }
  inline bool DataTieringEnabledHasBeenSet() const { return m_dataTieringEnabledHasBeenSet; }
  inline void SetDataTieringEnabled(bool value) {
    m_dataTieringEnabledHasBeenSet = true;
    m_dataTieringEnabled = value;
  }
  inline CreateReplicationGroupRequest& WithDataTieringEnabled(bool value) {
    SetDataTieringEnabled(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 CreateReplicationGroupRequest& 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 CreateReplicationGroupRequest& 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 CreateReplicationGroupRequest& 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 CreateReplicationGroupRequest& WithClusterMode(ClusterMode value) {
    SetClusterMode(value);
    return *this;
  }
 
 
  inline const Aws::String& GetServerlessCacheSnapshotName() const { return m_serverlessCacheSnapshotName; }
  inline bool ServerlessCacheSnapshotNameHasBeenSet() const { return m_serverlessCacheSnapshotNameHasBeenSet; }
  template <typename ServerlessCacheSnapshotNameT = Aws::String>
  void SetServerlessCacheSnapshotName(ServerlessCacheSnapshotNameT&& value) {
    m_serverlessCacheSnapshotNameHasBeenSet = true;
    m_serverlessCacheSnapshotName = std::forward<ServerlessCacheSnapshotNameT>(value);
  }
  template <typename ServerlessCacheSnapshotNameT = Aws::String>
  CreateReplicationGroupRequest& WithServerlessCacheSnapshotName(ServerlessCacheSnapshotNameT&& value) {
    SetServerlessCacheSnapshotName(std::forward<ServerlessCacheSnapshotNameT>(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 CreateReplicationGroupRequest& WithDurability(Durability value) {
    SetDurability(value);
    return *this;
  }
 private:
  Aws::String m_replicationGroupId;
 
  Aws::String m_replicationGroupDescription;
 
  Aws::String m_globalReplicationGroupId;
 
  Aws::String m_primaryClusterId;
 
  bool m_automaticFailoverEnabled{false};
 
  bool m_multiAZEnabled{false};
 
  int m_numCacheClusters{0};
 
  Aws::Vector<Aws::String> m_preferredCacheClusterAZs;
 
  int m_numNodeGroups{0};
 
  int m_replicasPerNodeGroup{0};
 
  Aws::Vector<NodeGroupConfiguration> m_nodeGroupConfiguration;
 
  Aws::String m_cacheNodeType;
 
  Aws::String m_engine;
 
  Aws::String m_engineVersion;
 
  Aws::String m_cacheParameterGroupName;
 
  Aws::String m_cacheSubnetGroupName;
 
  Aws::Vector<Aws::String> m_cacheSecurityGroupNames;
 
  Aws::Vector<Aws::String> m_securityGroupIds;
 
  Aws::Vector<Tag> m_tags;
 
  Aws::Vector<Aws::String> m_snapshotArns;
 
  Aws::String m_snapshotName;
 
  Aws::String m_preferredMaintenanceWindow;
 
  int m_port{0};
 
  Aws::String m_notificationTopicArn;
 
  bool m_autoMinorVersionUpgrade{false};
 
  int m_snapshotRetentionLimit{0};
 
  Aws::String m_snapshotWindow;
 
  Aws::String m_authToken;
 
  bool m_transitEncryptionEnabled{false};
 
  bool m_atRestEncryptionEnabled{false};
 
  Aws::String m_kmsKeyId;
 
  Aws::Vector<Aws::String> m_userGroupIds;
 
  Aws::Vector<LogDeliveryConfigurationRequest> m_logDeliveryConfigurations;
 
  bool m_dataTieringEnabled{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_serverlessCacheSnapshotName;
 
  Durability m_durability{Durability::NOT_SET};
  bool m_replicationGroupIdHasBeenSet = false;
  bool m_replicationGroupDescriptionHasBeenSet = false;
  bool m_globalReplicationGroupIdHasBeenSet = false;
  bool m_primaryClusterIdHasBeenSet = false;
  bool m_automaticFailoverEnabledHasBeenSet = false;
  bool m_multiAZEnabledHasBeenSet = false;
  bool m_numCacheClustersHasBeenSet = false;
  bool m_preferredCacheClusterAZsHasBeenSet = false;
  bool m_numNodeGroupsHasBeenSet = false;
  bool m_replicasPerNodeGroupHasBeenSet = false;
  bool m_nodeGroupConfigurationHasBeenSet = false;
  bool m_cacheNodeTypeHasBeenSet = false;
  bool m_engineHasBeenSet = false;
  bool m_engineVersionHasBeenSet = false;
  bool m_cacheParameterGroupNameHasBeenSet = false;
  bool m_cacheSubnetGroupNameHasBeenSet = false;
  bool m_cacheSecurityGroupNamesHasBeenSet = false;
  bool m_securityGroupIdsHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_snapshotArnsHasBeenSet = false;
  bool m_snapshotNameHasBeenSet = false;
  bool m_preferredMaintenanceWindowHasBeenSet = false;
  bool m_portHasBeenSet = false;
  bool m_notificationTopicArnHasBeenSet = false;
  bool m_autoMinorVersionUpgradeHasBeenSet = false;
  bool m_snapshotRetentionLimitHasBeenSet = false;
  bool m_snapshotWindowHasBeenSet = false;
  bool m_authTokenHasBeenSet = false;
  bool m_transitEncryptionEnabledHasBeenSet = false;
  bool m_atRestEncryptionEnabledHasBeenSet = false;
  bool m_kmsKeyIdHasBeenSet = false;
  bool m_userGroupIdsHasBeenSet = false;
  bool m_logDeliveryConfigurationsHasBeenSet = false;
  bool m_dataTieringEnabledHasBeenSet = false;
  bool m_networkTypeHasBeenSet = false;
  bool m_ipDiscoveryHasBeenSet = false;
  bool m_transitEncryptionModeHasBeenSet = false;
  bool m_clusterModeHasBeenSet = false;
  bool m_serverlessCacheSnapshotNameHasBeenSet = false;
  bool m_durabilityHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace ElastiCache
}  // namespace Aws