ModifyEndpointRequest.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.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/TimestreamSettings.h>
 
#include <utility>
 
namespace Aws {
namespace DatabaseMigrationService {
namespace Model {
 
class ModifyEndpointRequest : public DatabaseMigrationServiceRequest {
 public:
  AWS_DATABASEMIGRATIONSERVICE_API ModifyEndpointRequest() = 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 "ModifyEndpoint"; }
 
  AWS_DATABASEMIGRATIONSERVICE_API Aws::String SerializePayload() const override;
 
  AWS_DATABASEMIGRATIONSERVICE_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
 
 
  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>
  ModifyEndpointRequest& WithEndpointArn(EndpointArnT&& value) {
    SetEndpointArn(std::forward<EndpointArnT>(value));
    return *this;
  }
 
 
  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>
  ModifyEndpointRequest& 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 ModifyEndpointRequest& 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>
  ModifyEndpointRequest& 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>
  ModifyEndpointRequest& 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>
  ModifyEndpointRequest& 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>
  ModifyEndpointRequest& 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 ModifyEndpointRequest& 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>
  ModifyEndpointRequest& 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>
  ModifyEndpointRequest& WithExtraConnectionAttributes(ExtraConnectionAttributesT&& value) {
    SetExtraConnectionAttributes(std::forward<ExtraConnectionAttributesT>(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>
  ModifyEndpointRequest& 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 ModifyEndpointRequest& 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>
  ModifyEndpointRequest& 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>
  ModifyEndpointRequest& 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>
  ModifyEndpointRequest& 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>
  ModifyEndpointRequest& 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>
  ModifyEndpointRequest& 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>
  ModifyEndpointRequest& 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>
  ModifyEndpointRequest& 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>
  ModifyEndpointRequest& 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>
  ModifyEndpointRequest& 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>
  ModifyEndpointRequest& 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>
  ModifyEndpointRequest& 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>
  ModifyEndpointRequest& 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>
  ModifyEndpointRequest& 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>
  ModifyEndpointRequest& 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>
  ModifyEndpointRequest& 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>
  ModifyEndpointRequest& 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>
  ModifyEndpointRequest& 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>
  ModifyEndpointRequest& 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>
  ModifyEndpointRequest& WithRedisSettings(RedisSettingsT&& value) {
    SetRedisSettings(std::forward<RedisSettingsT>(value));
    return *this;
  }
 
 
  inline bool GetExactSettings() const { return m_exactSettings; }
  inline bool ExactSettingsHasBeenSet() const { return m_exactSettingsHasBeenSet; }
  inline void SetExactSettings(bool value) {
    m_exactSettingsHasBeenSet = true;
    m_exactSettings = value;
  }
  inline ModifyEndpointRequest& WithExactSettings(bool value) {
    SetExactSettings(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>
  ModifyEndpointRequest& 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>
  ModifyEndpointRequest& WithTimestreamSettings(TimestreamSettingsT&& value) {
    SetTimestreamSettings(std::forward<TimestreamSettingsT>(value));
    return *this;
  }
 private:
  Aws::String m_endpointArn;
 
  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_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;
 
  DocDbSettings m_docDbSettings;
 
  RedisSettings m_redisSettings;
 
  bool m_exactSettings{false};
 
  GcpMySQLSettings m_gcpMySQLSettings;
 
  TimestreamSettings m_timestreamSettings;
  bool m_endpointArnHasBeenSet = false;
  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_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_docDbSettingsHasBeenSet = false;
  bool m_redisSettingsHasBeenSet = false;
  bool m_exactSettingsHasBeenSet = false;
  bool m_gcpMySQLSettingsHasBeenSet = false;
  bool m_timestreamSettingsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace DatabaseMigrationService
}  // namespace Aws