DatabaseConfiguration.h

 
#pragma once
#include <aws/kendra/Kendra_EXPORTS.h>
#include <aws/kendra/model/AclConfiguration.h>
#include <aws/kendra/model/ColumnConfiguration.h>
#include <aws/kendra/model/ConnectionConfiguration.h>
#include <aws/kendra/model/DataSourceVpcConfiguration.h>
#include <aws/kendra/model/DatabaseEngineType.h>
#include <aws/kendra/model/SqlConfiguration.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace kendra {
namespace Model {
 
class DatabaseConfiguration {
 public:
  AWS_KENDRA_API DatabaseConfiguration() = default;
  AWS_KENDRA_API DatabaseConfiguration(Aws::Utils::Json::JsonView jsonValue);
  AWS_KENDRA_API DatabaseConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_KENDRA_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline DatabaseEngineType GetDatabaseEngineType() const { return m_databaseEngineType; }
  inline bool DatabaseEngineTypeHasBeenSet() const { return m_databaseEngineTypeHasBeenSet; }
  inline void SetDatabaseEngineType(DatabaseEngineType value) {
    m_databaseEngineTypeHasBeenSet = true;
    m_databaseEngineType = value;
  }
  inline DatabaseConfiguration& WithDatabaseEngineType(DatabaseEngineType value) {
    SetDatabaseEngineType(value);
    return *this;
  }
 
 
  inline const ConnectionConfiguration& GetConnectionConfiguration() const { return m_connectionConfiguration; }
  inline bool ConnectionConfigurationHasBeenSet() const { return m_connectionConfigurationHasBeenSet; }
  template <typename ConnectionConfigurationT = ConnectionConfiguration>
  void SetConnectionConfiguration(ConnectionConfigurationT&& value) {
    m_connectionConfigurationHasBeenSet = true;
    m_connectionConfiguration = std::forward<ConnectionConfigurationT>(value);
  }
  template <typename ConnectionConfigurationT = ConnectionConfiguration>
  DatabaseConfiguration& WithConnectionConfiguration(ConnectionConfigurationT&& value) {
    SetConnectionConfiguration(std::forward<ConnectionConfigurationT>(value));
    return *this;
  }
 
 
  inline const DataSourceVpcConfiguration& GetVpcConfiguration() const { return m_vpcConfiguration; }
  inline bool VpcConfigurationHasBeenSet() const { return m_vpcConfigurationHasBeenSet; }
  template <typename VpcConfigurationT = DataSourceVpcConfiguration>
  void SetVpcConfiguration(VpcConfigurationT&& value) {
    m_vpcConfigurationHasBeenSet = true;
    m_vpcConfiguration = std::forward<VpcConfigurationT>(value);
  }
  template <typename VpcConfigurationT = DataSourceVpcConfiguration>
  DatabaseConfiguration& WithVpcConfiguration(VpcConfigurationT&& value) {
    SetVpcConfiguration(std::forward<VpcConfigurationT>(value));
    return *this;
  }
 
 
  inline const ColumnConfiguration& GetColumnConfiguration() const { return m_columnConfiguration; }
  inline bool ColumnConfigurationHasBeenSet() const { return m_columnConfigurationHasBeenSet; }
  template <typename ColumnConfigurationT = ColumnConfiguration>
  void SetColumnConfiguration(ColumnConfigurationT&& value) {
    m_columnConfigurationHasBeenSet = true;
    m_columnConfiguration = std::forward<ColumnConfigurationT>(value);
  }
  template <typename ColumnConfigurationT = ColumnConfiguration>
  DatabaseConfiguration& WithColumnConfiguration(ColumnConfigurationT&& value) {
    SetColumnConfiguration(std::forward<ColumnConfigurationT>(value));
    return *this;
  }
 
 
  inline const AclConfiguration& GetAclConfiguration() const { return m_aclConfiguration; }
  inline bool AclConfigurationHasBeenSet() const { return m_aclConfigurationHasBeenSet; }
  template <typename AclConfigurationT = AclConfiguration>
  void SetAclConfiguration(AclConfigurationT&& value) {
    m_aclConfigurationHasBeenSet = true;
    m_aclConfiguration = std::forward<AclConfigurationT>(value);
  }
  template <typename AclConfigurationT = AclConfiguration>
  DatabaseConfiguration& WithAclConfiguration(AclConfigurationT&& value) {
    SetAclConfiguration(std::forward<AclConfigurationT>(value));
    return *this;
  }
 
 
  inline const SqlConfiguration& GetSqlConfiguration() const { return m_sqlConfiguration; }
  inline bool SqlConfigurationHasBeenSet() const { return m_sqlConfigurationHasBeenSet; }
  template <typename SqlConfigurationT = SqlConfiguration>
  void SetSqlConfiguration(SqlConfigurationT&& value) {
    m_sqlConfigurationHasBeenSet = true;
    m_sqlConfiguration = std::forward<SqlConfigurationT>(value);
  }
  template <typename SqlConfigurationT = SqlConfiguration>
  DatabaseConfiguration& WithSqlConfiguration(SqlConfigurationT&& value) {
    SetSqlConfiguration(std::forward<SqlConfigurationT>(value));
    return *this;
  }
 private:
  DatabaseEngineType m_databaseEngineType{DatabaseEngineType::NOT_SET};
 
  ConnectionConfiguration m_connectionConfiguration;
 
  DataSourceVpcConfiguration m_vpcConfiguration;
 
  ColumnConfiguration m_columnConfiguration;
 
  AclConfiguration m_aclConfiguration;
 
  SqlConfiguration m_sqlConfiguration;
  bool m_databaseEngineTypeHasBeenSet = false;
  bool m_connectionConfigurationHasBeenSet = false;
  bool m_vpcConfigurationHasBeenSet = false;
  bool m_columnConfigurationHasBeenSet = false;
  bool m_aclConfigurationHasBeenSet = false;
  bool m_sqlConfigurationHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace kendra
}  // namespace Aws