CreateEndpointRequest.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/dms/DatabaseMigrationServiceRequest.h>
#include <aws/dms/DatabaseMigrationService_EXPORTS.h>
#include <aws/dms/model/DmsSslModeValue.h>
#include <aws/dms/model/DmsTransferSettings.h>
#include <aws/dms/model/DocDbSettings.h>
#include <aws/dms/model/DynamoDbSettings.h>
#include <aws/dms/model/ElasticsearchSettings.h>
#include <aws/dms/model/GcpMySQLSettings.h>
#include <aws/dms/model/IBMDb2Settings.h>
#include <aws/dms/model/KafkaSettings.h>
#include <aws/dms/model/KinesisSettings.h>
#include <aws/dms/model/MicrosoftSQLServerSettings.h>
#include <aws/dms/model/MongoDbSettings.h>
#include <aws/dms/model/MySQLSettings.h>
#include <aws/dms/model/NeptuneSettings.h>
#include <aws/dms/model/OracleSettings.h>
#include <aws/dms/model/PostgreSQLSettings.h>
#include <aws/dms/model/RedisSettings.h>
#include <aws/dms/model/RedshiftSettings.h>
#include <aws/dms/model/ReplicationEndpointTypeValue.h>
#include <aws/dms/model/S3Settings.h>
#include <aws/dms/model/SybaseSettings.h>
#include <aws/dms/model/Tag.h>
#include <aws/dms/model/TimestreamSettings.h>
 
#include <utility>
 
namespace Aws {
namespace DatabaseMigrationService {
namespace Model {
 
class CreateEndpointRequest : public DatabaseMigrationServiceRequest {
 public:
  AWS_DATABASEMIGRATIONSERVICE_API CreateEndpointRequest() = 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 "CreateEndpoint"; }
 
  AWS_DATABASEMIGRATIONSERVICE_API Aws::String SerializePayload() const override;
 
  AWS_DATABASEMIGRATIONSERVICE_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
 
 
  inline const Aws::String& GetEndpointIdentifier() const { return m_endpointIdentifier; }
  inline bool EndpointIdentifierHasBeenSet() const { return m_endpointIdentifierHasBeenSet; }
  template <typename EndpointIdentifierT = Aws::String>
  void SetEndpointIdentifier(EndpointIdentifierT&& value) {
    m_endpointIdentifierHasBeenSet = true;
    m_endpointIdentifier = std::forward<EndpointIdentifierT>(value);
  }
  template <typename EndpointIdentifierT = Aws::String>
  CreateEndpointRequest& WithEndpointIdentifier(EndpointIdentifierT&& value) {
    SetEndpointIdentifier(std::forward<EndpointIdentifierT>(value));
    return *this;
  }
 
 
  inline ReplicationEndpointTypeValue GetEndpointType() const { return m_endpointType; }
  inline bool EndpointTypeHasBeenSet() const { return m_endpointTypeHasBeenSet; }
  inline void SetEndpointType(ReplicationEndpointTypeValue value) {
    m_endpointTypeHasBeenSet = true;
    m_endpointType = value;
  }
  inline CreateEndpointRequest& WithEndpointType(ReplicationEndpointTypeValue value) {
    SetEndpointType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetEngineName() const { return m_engineName; }
  inline bool EngineNameHasBeenSet() const { return m_engineNameHasBeenSet; }
  template <typename EngineNameT = Aws::String>
  void SetEngineName(EngineNameT&& value) {
    m_engineNameHasBeenSet = true;
    m_engineName = std::forward<EngineNameT>(value);
  }
  template <typename EngineNameT = Aws::String>
  CreateEndpointRequest& WithEngineName(EngineNameT&& value) {
    SetEngineName(std::forward<EngineNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetUsername() const { return m_username; }
  inline bool UsernameHasBeenSet() const { return m_usernameHasBeenSet; }
  template <typename UsernameT = Aws::String>
  void SetUsername(UsernameT&& value) {
    m_usernameHasBeenSet = true;
    m_username = std::forward<UsernameT>(value);
  }
  template <typename UsernameT = Aws::String>
  CreateEndpointRequest& WithUsername(UsernameT&& value) {
    SetUsername(std::forward<UsernameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPassword() const { return m_password; }
  inline bool PasswordHasBeenSet() const { return m_passwordHasBeenSet; }
  template <typename PasswordT = Aws::String>
  void SetPassword(PasswordT&& value) {
    m_passwordHasBeenSet = true;
    m_password = std::forward<PasswordT>(value);
  }
  template <typename PasswordT = Aws::String>
  CreateEndpointRequest& WithPassword(PasswordT&& value) {
    SetPassword(std::forward<PasswordT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetServerName() const { return m_serverName; }
  inline bool ServerNameHasBeenSet() const { return m_serverNameHasBeenSet; }
  template <typename ServerNameT = Aws::String>
  void SetServerName(ServerNameT&& value) {
    m_serverNameHasBeenSet = true;
    m_serverName = std::forward<ServerNameT>(value);
  }
  template <typename ServerNameT = Aws::String>
  CreateEndpointRequest& WithServerName(ServerNameT&& value) {
    SetServerName(std::forward<ServerNameT>(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 CreateEndpointRequest& WithPort(int value) {
    SetPort(value);
    return *this;
  }
 
 
  inline const Aws::String& GetDatabaseName() const { return m_databaseName; }
  inline bool DatabaseNameHasBeenSet() const { return m_databaseNameHasBeenSet; }
  template <typename DatabaseNameT = Aws::String>
  void SetDatabaseName(DatabaseNameT&& value) {
    m_databaseNameHasBeenSet = true;
    m_databaseName = std::forward<DatabaseNameT>(value);
  }
  template <typename DatabaseNameT = Aws::String>
  CreateEndpointRequest& WithDatabaseName(DatabaseNameT&& value) {
    SetDatabaseName(std::forward<DatabaseNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetExtraConnectionAttributes() const { return m_extraConnectionAttributes; }
  inline bool ExtraConnectionAttributesHasBeenSet() const { return m_extraConnectionAttributesHasBeenSet; }
  template <typename ExtraConnectionAttributesT = Aws::String>
  void SetExtraConnectionAttributes(ExtraConnectionAttributesT&& value) {
    m_extraConnectionAttributesHasBeenSet = true;
    m_extraConnectionAttributes = std::forward<ExtraConnectionAttributesT>(value);
  }
  template <typename ExtraConnectionAttributesT = Aws::String>
  CreateEndpointRequest& WithExtraConnectionAttributes(ExtraConnectionAttributesT&& value) {
    SetExtraConnectionAttributes(std::forward<ExtraConnectionAttributesT>(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>
  CreateEndpointRequest& WithKmsKeyId(KmsKeyIdT&& value) {
    SetKmsKeyId(std::forward<KmsKeyIdT>(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>>
  CreateEndpointRequest& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsT = Tag>
  CreateEndpointRequest& AddTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace_back(std::forward<TagsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCertificateArn() const { return m_certificateArn; }
  inline bool CertificateArnHasBeenSet() const { return m_certificateArnHasBeenSet; }
  template <typename CertificateArnT = Aws::String>
  void SetCertificateArn(CertificateArnT&& value) {
    m_certificateArnHasBeenSet = true;
    m_certificateArn = std::forward<CertificateArnT>(value);
  }
  template <typename CertificateArnT = Aws::String>
  CreateEndpointRequest& WithCertificateArn(CertificateArnT&& value) {
    SetCertificateArn(std::forward<CertificateArnT>(value));
    return *this;
  }
 
 
  inline DmsSslModeValue GetSslMode() const { return m_sslMode; }
  inline bool SslModeHasBeenSet() const { return m_sslModeHasBeenSet; }
  inline void SetSslMode(DmsSslModeValue value) {
    m_sslModeHasBeenSet = true;
    m_sslMode = value;
  }
  inline CreateEndpointRequest& WithSslMode(DmsSslModeValue value) {
    SetSslMode(value);
    return *this;
  }
 
 
  inline const Aws::String& GetServiceAccessRoleArn() const { return m_serviceAccessRoleArn; }
  inline bool ServiceAccessRoleArnHasBeenSet() const { return m_serviceAccessRoleArnHasBeenSet; }
  template <typename ServiceAccessRoleArnT = Aws::String>
  void SetServiceAccessRoleArn(ServiceAccessRoleArnT&& value) {
    m_serviceAccessRoleArnHasBeenSet = true;
    m_serviceAccessRoleArn = std::forward<ServiceAccessRoleArnT>(value);
  }
  template <typename ServiceAccessRoleArnT = Aws::String>
  CreateEndpointRequest& WithServiceAccessRoleArn(ServiceAccessRoleArnT&& value) {
    SetServiceAccessRoleArn(std::forward<ServiceAccessRoleArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetExternalTableDefinition() const { return m_externalTableDefinition; }
  inline bool ExternalTableDefinitionHasBeenSet() const { return m_externalTableDefinitionHasBeenSet; }
  template <typename ExternalTableDefinitionT = Aws::String>
  void SetExternalTableDefinition(ExternalTableDefinitionT&& value) {
    m_externalTableDefinitionHasBeenSet = true;
    m_externalTableDefinition = std::forward<ExternalTableDefinitionT>(value);
  }
  template <typename ExternalTableDefinitionT = Aws::String>
  CreateEndpointRequest& WithExternalTableDefinition(ExternalTableDefinitionT&& value) {
    SetExternalTableDefinition(std::forward<ExternalTableDefinitionT>(value));
    return *this;
  }
 
 
  inline const DynamoDbSettings& GetDynamoDbSettings() const { return m_dynamoDbSettings; }
  inline bool DynamoDbSettingsHasBeenSet() const { return m_dynamoDbSettingsHasBeenSet; }
  template <typename DynamoDbSettingsT = DynamoDbSettings>
  void SetDynamoDbSettings(DynamoDbSettingsT&& value) {
    m_dynamoDbSettingsHasBeenSet = true;
    m_dynamoDbSettings = std::forward<DynamoDbSettingsT>(value);
  }
  template <typename DynamoDbSettingsT = DynamoDbSettings>
  CreateEndpointRequest& WithDynamoDbSettings(DynamoDbSettingsT&& value) {
    SetDynamoDbSettings(std::forward<DynamoDbSettingsT>(value));
    return *this;
  }
 
 
  inline const S3Settings& GetS3Settings() const { return m_s3Settings; }
  inline bool S3SettingsHasBeenSet() const { return m_s3SettingsHasBeenSet; }
  template <typename S3SettingsT = S3Settings>
  void SetS3Settings(S3SettingsT&& value) {
    m_s3SettingsHasBeenSet = true;
    m_s3Settings = std::forward<S3SettingsT>(value);
  }
  template <typename S3SettingsT = S3Settings>
  CreateEndpointRequest& WithS3Settings(S3SettingsT&& value) {
    SetS3Settings(std::forward<S3SettingsT>(value));
    return *this;
  }
 
 
  inline const DmsTransferSettings& GetDmsTransferSettings() const { return m_dmsTransferSettings; }
  inline bool DmsTransferSettingsHasBeenSet() const { return m_dmsTransferSettingsHasBeenSet; }
  template <typename DmsTransferSettingsT = DmsTransferSettings>
  void SetDmsTransferSettings(DmsTransferSettingsT&& value) {
    m_dmsTransferSettingsHasBeenSet = true;
    m_dmsTransferSettings = std::forward<DmsTransferSettingsT>(value);
  }
  template <typename DmsTransferSettingsT = DmsTransferSettings>
  CreateEndpointRequest& WithDmsTransferSettings(DmsTransferSettingsT&& value) {
    SetDmsTransferSettings(std::forward<DmsTransferSettingsT>(value));
    return *this;
  }
 
 
  inline const MongoDbSettings& GetMongoDbSettings() const { return m_mongoDbSettings; }
  inline bool MongoDbSettingsHasBeenSet() const { return m_mongoDbSettingsHasBeenSet; }
  template <typename MongoDbSettingsT = MongoDbSettings>
  void SetMongoDbSettings(MongoDbSettingsT&& value) {
    m_mongoDbSettingsHasBeenSet = true;
    m_mongoDbSettings = std::forward<MongoDbSettingsT>(value);
  }
  template <typename MongoDbSettingsT = MongoDbSettings>
  CreateEndpointRequest& WithMongoDbSettings(MongoDbSettingsT&& value) {
    SetMongoDbSettings(std::forward<MongoDbSettingsT>(value));
    return *this;
  }
 
 
  inline const KinesisSettings& GetKinesisSettings() const { return m_kinesisSettings; }
  inline bool KinesisSettingsHasBeenSet() const { return m_kinesisSettingsHasBeenSet; }
  template <typename KinesisSettingsT = KinesisSettings>
  void SetKinesisSettings(KinesisSettingsT&& value) {
    m_kinesisSettingsHasBeenSet = true;
    m_kinesisSettings = std::forward<KinesisSettingsT>(value);
  }
  template <typename KinesisSettingsT = KinesisSettings>
  CreateEndpointRequest& WithKinesisSettings(KinesisSettingsT&& value) {
    SetKinesisSettings(std::forward<KinesisSettingsT>(value));
    return *this;
  }
 
 
  inline const KafkaSettings& GetKafkaSettings() const { return m_kafkaSettings; }
  inline bool KafkaSettingsHasBeenSet() const { return m_kafkaSettingsHasBeenSet; }
  template <typename KafkaSettingsT = KafkaSettings>
  void SetKafkaSettings(KafkaSettingsT&& value) {
    m_kafkaSettingsHasBeenSet = true;
    m_kafkaSettings = std::forward<KafkaSettingsT>(value);
  }
  template <typename KafkaSettingsT = KafkaSettings>
  CreateEndpointRequest& WithKafkaSettings(KafkaSettingsT&& value) {
    SetKafkaSettings(std::forward<KafkaSettingsT>(value));
    return *this;
  }
 
 
  inline const ElasticsearchSettings& GetElasticsearchSettings() const { return m_elasticsearchSettings; }
  inline bool ElasticsearchSettingsHasBeenSet() const { return m_elasticsearchSettingsHasBeenSet; }
  template <typename ElasticsearchSettingsT = ElasticsearchSettings>
  void SetElasticsearchSettings(ElasticsearchSettingsT&& value) {
    m_elasticsearchSettingsHasBeenSet = true;
    m_elasticsearchSettings = std::forward<ElasticsearchSettingsT>(value);
  }
  template <typename ElasticsearchSettingsT = ElasticsearchSettings>
  CreateEndpointRequest& WithElasticsearchSettings(ElasticsearchSettingsT&& value) {
    SetElasticsearchSettings(std::forward<ElasticsearchSettingsT>(value));
    return *this;
  }
 
 
  inline const NeptuneSettings& GetNeptuneSettings() const { return m_neptuneSettings; }
  inline bool NeptuneSettingsHasBeenSet() const { return m_neptuneSettingsHasBeenSet; }
  template <typename NeptuneSettingsT = NeptuneSettings>
  void SetNeptuneSettings(NeptuneSettingsT&& value) {
    m_neptuneSettingsHasBeenSet = true;
    m_neptuneSettings = std::forward<NeptuneSettingsT>(value);
  }
  template <typename NeptuneSettingsT = NeptuneSettings>
  CreateEndpointRequest& WithNeptuneSettings(NeptuneSettingsT&& value) {
    SetNeptuneSettings(std::forward<NeptuneSettingsT>(value));
    return *this;
  }
 
 
  inline const RedshiftSettings& GetRedshiftSettings() const { return m_redshiftSettings; }
  inline bool RedshiftSettingsHasBeenSet() const { return m_redshiftSettingsHasBeenSet; }
  template <typename RedshiftSettingsT = RedshiftSettings>
  void SetRedshiftSettings(RedshiftSettingsT&& value) {
    m_redshiftSettingsHasBeenSet = true;
    m_redshiftSettings = std::forward<RedshiftSettingsT>(value);
  }
  template <typename RedshiftSettingsT = RedshiftSettings>
  CreateEndpointRequest& WithRedshiftSettings(RedshiftSettingsT&& value) {
    SetRedshiftSettings(std::forward<RedshiftSettingsT>(value));
    return *this;
  }
 
 
  inline const PostgreSQLSettings& GetPostgreSQLSettings() const { return m_postgreSQLSettings; }
  inline bool PostgreSQLSettingsHasBeenSet() const { return m_postgreSQLSettingsHasBeenSet; }
  template <typename PostgreSQLSettingsT = PostgreSQLSettings>
  void SetPostgreSQLSettings(PostgreSQLSettingsT&& value) {
    m_postgreSQLSettingsHasBeenSet = true;
    m_postgreSQLSettings = std::forward<PostgreSQLSettingsT>(value);
  }
  template <typename PostgreSQLSettingsT = PostgreSQLSettings>
  CreateEndpointRequest& WithPostgreSQLSettings(PostgreSQLSettingsT&& value) {
    SetPostgreSQLSettings(std::forward<PostgreSQLSettingsT>(value));
    return *this;
  }
 
 
  inline const MySQLSettings& GetMySQLSettings() const { return m_mySQLSettings; }
  inline bool MySQLSettingsHasBeenSet() const { return m_mySQLSettingsHasBeenSet; }
  template <typename MySQLSettingsT = MySQLSettings>
  void SetMySQLSettings(MySQLSettingsT&& value) {
    m_mySQLSettingsHasBeenSet = true;
    m_mySQLSettings = std::forward<MySQLSettingsT>(value);
  }
  template <typename MySQLSettingsT = MySQLSettings>
  CreateEndpointRequest& WithMySQLSettings(MySQLSettingsT&& value) {
    SetMySQLSettings(std::forward<MySQLSettingsT>(value));
    return *this;
  }
 
 
  inline const OracleSettings& GetOracleSettings() const { return m_oracleSettings; }
  inline bool OracleSettingsHasBeenSet() const { return m_oracleSettingsHasBeenSet; }
  template <typename OracleSettingsT = OracleSettings>
  void SetOracleSettings(OracleSettingsT&& value) {
    m_oracleSettingsHasBeenSet = true;
    m_oracleSettings = std::forward<OracleSettingsT>(value);
  }
  template <typename OracleSettingsT = OracleSettings>
  CreateEndpointRequest& WithOracleSettings(OracleSettingsT&& value) {
    SetOracleSettings(std::forward<OracleSettingsT>(value));
    return *this;
  }
 
 
  inline const SybaseSettings& GetSybaseSettings() const { return m_sybaseSettings; }
  inline bool SybaseSettingsHasBeenSet() const { return m_sybaseSettingsHasBeenSet; }
  template <typename SybaseSettingsT = SybaseSettings>
  void SetSybaseSettings(SybaseSettingsT&& value) {
    m_sybaseSettingsHasBeenSet = true;
    m_sybaseSettings = std::forward<SybaseSettingsT>(value);
  }
  template <typename SybaseSettingsT = SybaseSettings>
  CreateEndpointRequest& WithSybaseSettings(SybaseSettingsT&& value) {
    SetSybaseSettings(std::forward<SybaseSettingsT>(value));
    return *this;
  }
 
 
  inline const MicrosoftSQLServerSettings& GetMicrosoftSQLServerSettings() const { return m_microsoftSQLServerSettings; }
  inline bool MicrosoftSQLServerSettingsHasBeenSet() const { return m_microsoftSQLServerSettingsHasBeenSet; }
  template <typename MicrosoftSQLServerSettingsT = MicrosoftSQLServerSettings>
  void SetMicrosoftSQLServerSettings(MicrosoftSQLServerSettingsT&& value) {
    m_microsoftSQLServerSettingsHasBeenSet = true;
    m_microsoftSQLServerSettings = std::forward<MicrosoftSQLServerSettingsT>(value);
  }
  template <typename MicrosoftSQLServerSettingsT = MicrosoftSQLServerSettings>
  CreateEndpointRequest& WithMicrosoftSQLServerSettings(MicrosoftSQLServerSettingsT&& value) {
    SetMicrosoftSQLServerSettings(std::forward<MicrosoftSQLServerSettingsT>(value));
    return *this;
  }
 
 
  inline const IBMDb2Settings& GetIBMDb2Settings() const { return m_iBMDb2Settings; }
  inline bool IBMDb2SettingsHasBeenSet() const { return m_iBMDb2SettingsHasBeenSet; }
  template <typename IBMDb2SettingsT = IBMDb2Settings>
  void SetIBMDb2Settings(IBMDb2SettingsT&& value) {
    m_iBMDb2SettingsHasBeenSet = true;
    m_iBMDb2Settings = std::forward<IBMDb2SettingsT>(value);
  }
  template <typename IBMDb2SettingsT = IBMDb2Settings>
  CreateEndpointRequest& WithIBMDb2Settings(IBMDb2SettingsT&& value) {
    SetIBMDb2Settings(std::forward<IBMDb2SettingsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetResourceIdentifier() const { return m_resourceIdentifier; }
  inline bool ResourceIdentifierHasBeenSet() const { return m_resourceIdentifierHasBeenSet; }
  template <typename ResourceIdentifierT = Aws::String>
  void SetResourceIdentifier(ResourceIdentifierT&& value) {
    m_resourceIdentifierHasBeenSet = true;
    m_resourceIdentifier = std::forward<ResourceIdentifierT>(value);
  }
  template <typename ResourceIdentifierT = Aws::String>
  CreateEndpointRequest& WithResourceIdentifier(ResourceIdentifierT&& value) {
    SetResourceIdentifier(std::forward<ResourceIdentifierT>(value));
    return *this;
  }
 
 
  inline const DocDbSettings& GetDocDbSettings() const { return m_docDbSettings; }
  inline bool DocDbSettingsHasBeenSet() const { return m_docDbSettingsHasBeenSet; }
  template <typename DocDbSettingsT = DocDbSettings>
  void SetDocDbSettings(DocDbSettingsT&& value) {
    m_docDbSettingsHasBeenSet = true;
    m_docDbSettings = std::forward<DocDbSettingsT>(value);
  }
  template <typename DocDbSettingsT = DocDbSettings>
  CreateEndpointRequest& WithDocDbSettings(DocDbSettingsT&& value) {
    SetDocDbSettings(std::forward<DocDbSettingsT>(value));
    return *this;
  }
 
 
  inline const RedisSettings& GetRedisSettings() const { return m_redisSettings; }
  inline bool RedisSettingsHasBeenSet() const { return m_redisSettingsHasBeenSet; }
  template <typename RedisSettingsT = RedisSettings>
  void SetRedisSettings(RedisSettingsT&& value) {
    m_redisSettingsHasBeenSet = true;
    m_redisSettings = std::forward<RedisSettingsT>(value);
  }
  template <typename RedisSettingsT = RedisSettings>
  CreateEndpointRequest& WithRedisSettings(RedisSettingsT&& value) {
    SetRedisSettings(std::forward<RedisSettingsT>(value));
    return *this;
  }
 
 
  inline const GcpMySQLSettings& GetGcpMySQLSettings() const { return m_gcpMySQLSettings; }
  inline bool GcpMySQLSettingsHasBeenSet() const { return m_gcpMySQLSettingsHasBeenSet; }
  template <typename GcpMySQLSettingsT = GcpMySQLSettings>
  void SetGcpMySQLSettings(GcpMySQLSettingsT&& value) {
    m_gcpMySQLSettingsHasBeenSet = true;
    m_gcpMySQLSettings = std::forward<GcpMySQLSettingsT>(value);
  }
  template <typename GcpMySQLSettingsT = GcpMySQLSettings>
  CreateEndpointRequest& WithGcpMySQLSettings(GcpMySQLSettingsT&& value) {
    SetGcpMySQLSettings(std::forward<GcpMySQLSettingsT>(value));
    return *this;
  }
 
 
  inline const TimestreamSettings& GetTimestreamSettings() const { return m_timestreamSettings; }
  inline bool TimestreamSettingsHasBeenSet() const { return m_timestreamSettingsHasBeenSet; }
  template <typename TimestreamSettingsT = TimestreamSettings>
  void SetTimestreamSettings(TimestreamSettingsT&& value) {
    m_timestreamSettingsHasBeenSet = true;
    m_timestreamSettings = std::forward<TimestreamSettingsT>(value);
  }
  template <typename TimestreamSettingsT = TimestreamSettings>
  CreateEndpointRequest& WithTimestreamSettings(TimestreamSettingsT&& value) {
    SetTimestreamSettings(std::forward<TimestreamSettingsT>(value));
    return *this;
  }
 private:
  Aws::String m_endpointIdentifier;
 
  ReplicationEndpointTypeValue m_endpointType{ReplicationEndpointTypeValue::NOT_SET};
 
  Aws::String m_engineName;
 
  Aws::String m_username;
 
  Aws::String m_password;
 
  Aws::String m_serverName;
 
  int m_port{0};
 
  Aws::String m_databaseName;
 
  Aws::String m_extraConnectionAttributes;
 
  Aws::String m_kmsKeyId;
 
  Aws::Vector<Tag> m_tags;
 
  Aws::String m_certificateArn;
 
  DmsSslModeValue m_sslMode{DmsSslModeValue::NOT_SET};
 
  Aws::String m_serviceAccessRoleArn;
 
  Aws::String m_externalTableDefinition;
 
  DynamoDbSettings m_dynamoDbSettings;
 
  S3Settings m_s3Settings;
 
  DmsTransferSettings m_dmsTransferSettings;
 
  MongoDbSettings m_mongoDbSettings;
 
  KinesisSettings m_kinesisSettings;
 
  KafkaSettings m_kafkaSettings;
 
  ElasticsearchSettings m_elasticsearchSettings;
 
  NeptuneSettings m_neptuneSettings;
 
  RedshiftSettings m_redshiftSettings;
 
  PostgreSQLSettings m_postgreSQLSettings;
 
  MySQLSettings m_mySQLSettings;
 
  OracleSettings m_oracleSettings;
 
  SybaseSettings m_sybaseSettings;
 
  MicrosoftSQLServerSettings m_microsoftSQLServerSettings;
 
  IBMDb2Settings m_iBMDb2Settings;
 
  Aws::String m_resourceIdentifier;
 
  DocDbSettings m_docDbSettings;
 
  RedisSettings m_redisSettings;
 
  GcpMySQLSettings m_gcpMySQLSettings;
 
  TimestreamSettings m_timestreamSettings;
  bool m_endpointIdentifierHasBeenSet = false;
  bool m_endpointTypeHasBeenSet = false;
  bool m_engineNameHasBeenSet = false;
  bool m_usernameHasBeenSet = false;
  bool m_passwordHasBeenSet = false;
  bool m_serverNameHasBeenSet = false;
  bool m_portHasBeenSet = false;
  bool m_databaseNameHasBeenSet = false;
  bool m_extraConnectionAttributesHasBeenSet = false;
  bool m_kmsKeyIdHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_certificateArnHasBeenSet = false;
  bool m_sslModeHasBeenSet = false;
  bool m_serviceAccessRoleArnHasBeenSet = false;
  bool m_externalTableDefinitionHasBeenSet = false;
  bool m_dynamoDbSettingsHasBeenSet = false;
  bool m_s3SettingsHasBeenSet = false;
  bool m_dmsTransferSettingsHasBeenSet = false;
  bool m_mongoDbSettingsHasBeenSet = false;
  bool m_kinesisSettingsHasBeenSet = false;
  bool m_kafkaSettingsHasBeenSet = false;
  bool m_elasticsearchSettingsHasBeenSet = false;
  bool m_neptuneSettingsHasBeenSet = false;
  bool m_redshiftSettingsHasBeenSet = false;
  bool m_postgreSQLSettingsHasBeenSet = false;
  bool m_mySQLSettingsHasBeenSet = false;
  bool m_oracleSettingsHasBeenSet = false;
  bool m_sybaseSettingsHasBeenSet = false;
  bool m_microsoftSQLServerSettingsHasBeenSet = false;
  bool m_iBMDb2SettingsHasBeenSet = false;
  bool m_resourceIdentifierHasBeenSet = false;
  bool m_docDbSettingsHasBeenSet = false;
  bool m_redisSettingsHasBeenSet = false;
  bool m_gcpMySQLSettingsHasBeenSet = false;
  bool m_timestreamSettingsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace DatabaseMigrationService
}  // namespace Aws