RedshiftDataParameters.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/eventbridge/EventBridge_EXPORTS.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace EventBridge {
namespace Model {
 
class RedshiftDataParameters {
 public:
  AWS_EVENTBRIDGE_API RedshiftDataParameters() = default;
  AWS_EVENTBRIDGE_API RedshiftDataParameters(Aws::Utils::Json::JsonView jsonValue);
  AWS_EVENTBRIDGE_API RedshiftDataParameters& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_EVENTBRIDGE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetSecretManagerArn() const { return m_secretManagerArn; }
  inline bool SecretManagerArnHasBeenSet() const { return m_secretManagerArnHasBeenSet; }
  template <typename SecretManagerArnT = Aws::String>
  void SetSecretManagerArn(SecretManagerArnT&& value) {
    m_secretManagerArnHasBeenSet = true;
    m_secretManagerArn = std::forward<SecretManagerArnT>(value);
  }
  template <typename SecretManagerArnT = Aws::String>
  RedshiftDataParameters& WithSecretManagerArn(SecretManagerArnT&& value) {
    SetSecretManagerArn(std::forward<SecretManagerArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDatabase() const { return m_database; }
  inline bool DatabaseHasBeenSet() const { return m_databaseHasBeenSet; }
  template <typename DatabaseT = Aws::String>
  void SetDatabase(DatabaseT&& value) {
    m_databaseHasBeenSet = true;
    m_database = std::forward<DatabaseT>(value);
  }
  template <typename DatabaseT = Aws::String>
  RedshiftDataParameters& WithDatabase(DatabaseT&& value) {
    SetDatabase(std::forward<DatabaseT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDbUser() const { return m_dbUser; }
  inline bool DbUserHasBeenSet() const { return m_dbUserHasBeenSet; }
  template <typename DbUserT = Aws::String>
  void SetDbUser(DbUserT&& value) {
    m_dbUserHasBeenSet = true;
    m_dbUser = std::forward<DbUserT>(value);
  }
  template <typename DbUserT = Aws::String>
  RedshiftDataParameters& WithDbUser(DbUserT&& value) {
    SetDbUser(std::forward<DbUserT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSql() const { return m_sql; }
  inline bool SqlHasBeenSet() const { return m_sqlHasBeenSet; }
  template <typename SqlT = Aws::String>
  void SetSql(SqlT&& value) {
    m_sqlHasBeenSet = true;
    m_sql = std::forward<SqlT>(value);
  }
  template <typename SqlT = Aws::String>
  RedshiftDataParameters& WithSql(SqlT&& value) {
    SetSql(std::forward<SqlT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetStatementName() const { return m_statementName; }
  inline bool StatementNameHasBeenSet() const { return m_statementNameHasBeenSet; }
  template <typename StatementNameT = Aws::String>
  void SetStatementName(StatementNameT&& value) {
    m_statementNameHasBeenSet = true;
    m_statementName = std::forward<StatementNameT>(value);
  }
  template <typename StatementNameT = Aws::String>
  RedshiftDataParameters& WithStatementName(StatementNameT&& value) {
    SetStatementName(std::forward<StatementNameT>(value));
    return *this;
  }
 
 
  inline bool GetWithEvent() const { return m_withEvent; }
  inline bool WithEventHasBeenSet() const { return m_withEventHasBeenSet; }
  inline void SetWithEvent(bool value) {
    m_withEventHasBeenSet = true;
    m_withEvent = value;
  }
  inline RedshiftDataParameters& WithWithEvent(bool value) {
    SetWithEvent(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetSqls() const { return m_sqls; }
  inline bool SqlsHasBeenSet() const { return m_sqlsHasBeenSet; }
  template <typename SqlsT = Aws::Vector<Aws::String>>
  void SetSqls(SqlsT&& value) {
    m_sqlsHasBeenSet = true;
    m_sqls = std::forward<SqlsT>(value);
  }
  template <typename SqlsT = Aws::Vector<Aws::String>>
  RedshiftDataParameters& WithSqls(SqlsT&& value) {
    SetSqls(std::forward<SqlsT>(value));
    return *this;
  }
  template <typename SqlsT = Aws::String>
  RedshiftDataParameters& AddSqls(SqlsT&& value) {
    m_sqlsHasBeenSet = true;
    m_sqls.emplace_back(std::forward<SqlsT>(value));
    return *this;
  }
 private:
  Aws::String m_secretManagerArn;
 
  Aws::String m_database;
 
  Aws::String m_dbUser;
 
  Aws::String m_sql;
 
  Aws::String m_statementName;
 
  bool m_withEvent{false};
 
  Aws::Vector<Aws::String> m_sqls;
  bool m_secretManagerArnHasBeenSet = false;
  bool m_databaseHasBeenSet = false;
  bool m_dbUserHasBeenSet = false;
  bool m_sqlHasBeenSet = false;
  bool m_statementNameHasBeenSet = false;
  bool m_withEventHasBeenSet = false;
  bool m_sqlsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace EventBridge
}  // namespace Aws