Endpoint.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.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/LakehouseSettings.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/TimestreamSettings.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace DatabaseMigrationService {
namespace Model {
 
class Endpoint {
 public:
  AWS_DATABASEMIGRATIONSERVICE_API Endpoint() = default;
  AWS_DATABASEMIGRATIONSERVICE_API Endpoint(Aws::Utils::Json::JsonView jsonValue);
  AWS_DATABASEMIGRATIONSERVICE_API Endpoint& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_DATABASEMIGRATIONSERVICE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  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>
  Endpoint& 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 Endpoint& 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>
  Endpoint& WithEngineName(EngineNameT&& value) {
    SetEngineName(std::forward<EngineNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetEngineDisplayName() const { return m_engineDisplayName; }
  inline bool EngineDisplayNameHasBeenSet() const { return m_engineDisplayNameHasBeenSet; }
  template <typename EngineDisplayNameT = Aws::String>
  void SetEngineDisplayName(EngineDisplayNameT&& value) {
    m_engineDisplayNameHasBeenSet = true;
    m_engineDisplayName = std::forward<EngineDisplayNameT>(value);
  }
  template <typename EngineDisplayNameT = Aws::String>
  Endpoint& WithEngineDisplayName(EngineDisplayNameT&& value) {
    SetEngineDisplayName(std::forward<EngineDisplayNameT>(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>
  Endpoint& WithUsername(UsernameT&& value) {
    SetUsername(std::forward<UsernameT>(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>
  Endpoint& 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 Endpoint& 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>
  Endpoint& 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>
  Endpoint& WithExtraConnectionAttributes(ExtraConnectionAttributesT&& value) {
    SetExtraConnectionAttributes(std::forward<ExtraConnectionAttributesT>(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>
  Endpoint& WithStatus(StatusT&& value) {
    SetStatus(std::forward<StatusT>(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>
  Endpoint& WithKmsKeyId(KmsKeyIdT&& value) {
    SetKmsKeyId(std::forward<KmsKeyIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetEndpointArn() const { return m_endpointArn; }
  inline bool EndpointArnHasBeenSet() const { return m_endpointArnHasBeenSet; }
  template <typename EndpointArnT = Aws::String>
  void SetEndpointArn(EndpointArnT&& value) {
    m_endpointArnHasBeenSet = true;
    m_endpointArn = std::forward<EndpointArnT>(value);
  }
  template <typename EndpointArnT = Aws::String>
  Endpoint& WithEndpointArn(EndpointArnT&& value) {
    SetEndpointArn(std::forward<EndpointArnT>(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>
  Endpoint& 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 Endpoint& 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>
  Endpoint& 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>
  Endpoint& WithExternalTableDefinition(ExternalTableDefinitionT&& value) {
    SetExternalTableDefinition(std::forward<ExternalTableDefinitionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetExternalId() const { return m_externalId; }
  inline bool ExternalIdHasBeenSet() const { return m_externalIdHasBeenSet; }
  template <typename ExternalIdT = Aws::String>
  void SetExternalId(ExternalIdT&& value) {
    m_externalIdHasBeenSet = true;
    m_externalId = std::forward<ExternalIdT>(value);
  }
  template <typename ExternalIdT = Aws::String>
  Endpoint& WithExternalId(ExternalIdT&& value) {
    SetExternalId(std::forward<ExternalIdT>(value));
    return *this;
  }
 
 
  inline bool GetIsReadOnly() const { return m_isReadOnly; }
  inline bool IsReadOnlyHasBeenSet() const { return m_isReadOnlyHasBeenSet; }
  inline void SetIsReadOnly(bool value) {
    m_isReadOnlyHasBeenSet = true;
    m_isReadOnly = value;
  }
  inline Endpoint& WithIsReadOnly(bool value) {
    SetIsReadOnly(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>
  Endpoint& 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>
  Endpoint& 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>
  Endpoint& 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>
  Endpoint& 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>
  Endpoint& 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>
  Endpoint& 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>
  Endpoint& 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>
  Endpoint& 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>
  Endpoint& 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>
  Endpoint& 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>
  Endpoint& 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>
  Endpoint& 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>
  Endpoint& 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>
  Endpoint& 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>
  Endpoint& WithIBMDb2Settings(IBMDb2SettingsT&& value) {
    SetIBMDb2Settings(std::forward<IBMDb2SettingsT>(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>
  Endpoint& 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>
  Endpoint& 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>
  Endpoint& 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>
  Endpoint& WithTimestreamSettings(TimestreamSettingsT&& value) {
    SetTimestreamSettings(std::forward<TimestreamSettingsT>(value));
    return *this;
  }
 
 
  inline const LakehouseSettings& GetLakehouseSettings() const { return m_lakehouseSettings; }
  inline bool LakehouseSettingsHasBeenSet() const { return m_lakehouseSettingsHasBeenSet; }
  template <typename LakehouseSettingsT = LakehouseSettings>
  void SetLakehouseSettings(LakehouseSettingsT&& value) {
    m_lakehouseSettingsHasBeenSet = true;
    m_lakehouseSettings = std::forward<LakehouseSettingsT>(value);
  }
  template <typename LakehouseSettingsT = LakehouseSettings>
  Endpoint& WithLakehouseSettings(LakehouseSettingsT&& value) {
    SetLakehouseSettings(std::forward<LakehouseSettingsT>(value));
    return *this;
  }
 private:
  Aws::String m_endpointIdentifier;
 
  ReplicationEndpointTypeValue m_endpointType{ReplicationEndpointTypeValue::NOT_SET};
 
  Aws::String m_engineName;
 
  Aws::String m_engineDisplayName;
 
  Aws::String m_username;
 
  Aws::String m_serverName;
 
  int m_port{0};
 
  Aws::String m_databaseName;
 
  Aws::String m_extraConnectionAttributes;
 
  Aws::String m_status;
 
  Aws::String m_kmsKeyId;
 
  Aws::String m_endpointArn;
 
  Aws::String m_certificateArn;
 
  DmsSslModeValue m_sslMode{DmsSslModeValue::NOT_SET};
 
  Aws::String m_serviceAccessRoleArn;
 
  Aws::String m_externalTableDefinition;
 
  Aws::String m_externalId;
 
  bool m_isReadOnly{false};
 
  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;
 
  DocDbSettings m_docDbSettings;
 
  RedisSettings m_redisSettings;
 
  GcpMySQLSettings m_gcpMySQLSettings;
 
  TimestreamSettings m_timestreamSettings;
 
  LakehouseSettings m_lakehouseSettings;
  bool m_endpointIdentifierHasBeenSet = false;
  bool m_endpointTypeHasBeenSet = false;
  bool m_engineNameHasBeenSet = false;
  bool m_engineDisplayNameHasBeenSet = false;
  bool m_usernameHasBeenSet = false;
  bool m_serverNameHasBeenSet = false;
  bool m_portHasBeenSet = false;
  bool m_databaseNameHasBeenSet = false;
  bool m_extraConnectionAttributesHasBeenSet = false;
  bool m_statusHasBeenSet = false;
  bool m_kmsKeyIdHasBeenSet = false;
  bool m_endpointArnHasBeenSet = false;
  bool m_certificateArnHasBeenSet = false;
  bool m_sslModeHasBeenSet = false;
  bool m_serviceAccessRoleArnHasBeenSet = false;
  bool m_externalTableDefinitionHasBeenSet = false;
  bool m_externalIdHasBeenSet = false;
  bool m_isReadOnlyHasBeenSet = 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_docDbSettingsHasBeenSet = false;
  bool m_redisSettingsHasBeenSet = false;
  bool m_gcpMySQLSettingsHasBeenSet = false;
  bool m_timestreamSettingsHasBeenSet = false;
  bool m_lakehouseSettingsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace DatabaseMigrationService
}  // namespace Aws