ModifyLakehouseConfigurationRequest.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/redshift/RedshiftRequest.h>
#include <aws/redshift/Redshift_EXPORTS.h>
#include <aws/redshift/model/LakehouseIdcRegistration.h>
#include <aws/redshift/model/LakehouseRegistration.h>
 
#include <utility>
 
namespace Aws {
namespace Redshift {
namespace Model {
 
class ModifyLakehouseConfigurationRequest : public RedshiftRequest {
 public:
  AWS_REDSHIFT_API ModifyLakehouseConfigurationRequest() = 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 "ModifyLakehouseConfiguration"; }
 
  AWS_REDSHIFT_API Aws::String SerializePayload() const override;
 
 protected:
  AWS_REDSHIFT_API void DumpBodyToUrl(Aws::Http::URI& uri) const override;
 
 public:
 
  inline const Aws::String& GetClusterIdentifier() const { return m_clusterIdentifier; }
  inline bool ClusterIdentifierHasBeenSet() const { return m_clusterIdentifierHasBeenSet; }
  template <typename ClusterIdentifierT = Aws::String>
  void SetClusterIdentifier(ClusterIdentifierT&& value) {
    m_clusterIdentifierHasBeenSet = true;
    m_clusterIdentifier = std::forward<ClusterIdentifierT>(value);
  }
  template <typename ClusterIdentifierT = Aws::String>
  ModifyLakehouseConfigurationRequest& WithClusterIdentifier(ClusterIdentifierT&& value) {
    SetClusterIdentifier(std::forward<ClusterIdentifierT>(value));
    return *this;
  }
 
 
  inline LakehouseRegistration GetLakehouseRegistration() const { return m_lakehouseRegistration; }
  inline bool LakehouseRegistrationHasBeenSet() const { return m_lakehouseRegistrationHasBeenSet; }
  inline void SetLakehouseRegistration(LakehouseRegistration value) {
    m_lakehouseRegistrationHasBeenSet = true;
    m_lakehouseRegistration = value;
  }
  inline ModifyLakehouseConfigurationRequest& WithLakehouseRegistration(LakehouseRegistration value) {
    SetLakehouseRegistration(value);
    return *this;
  }
 
 
  inline const Aws::String& GetCatalogName() const { return m_catalogName; }
  inline bool CatalogNameHasBeenSet() const { return m_catalogNameHasBeenSet; }
  template <typename CatalogNameT = Aws::String>
  void SetCatalogName(CatalogNameT&& value) {
    m_catalogNameHasBeenSet = true;
    m_catalogName = std::forward<CatalogNameT>(value);
  }
  template <typename CatalogNameT = Aws::String>
  ModifyLakehouseConfigurationRequest& WithCatalogName(CatalogNameT&& value) {
    SetCatalogName(std::forward<CatalogNameT>(value));
    return *this;
  }
 
 
  inline LakehouseIdcRegistration GetLakehouseIdcRegistration() const { return m_lakehouseIdcRegistration; }
  inline bool LakehouseIdcRegistrationHasBeenSet() const { return m_lakehouseIdcRegistrationHasBeenSet; }
  inline void SetLakehouseIdcRegistration(LakehouseIdcRegistration value) {
    m_lakehouseIdcRegistrationHasBeenSet = true;
    m_lakehouseIdcRegistration = value;
  }
  inline ModifyLakehouseConfigurationRequest& WithLakehouseIdcRegistration(LakehouseIdcRegistration value) {
    SetLakehouseIdcRegistration(value);
    return *this;
  }
 
 
  inline const Aws::String& GetLakehouseIdcApplicationArn() const { return m_lakehouseIdcApplicationArn; }
  inline bool LakehouseIdcApplicationArnHasBeenSet() const { return m_lakehouseIdcApplicationArnHasBeenSet; }
  template <typename LakehouseIdcApplicationArnT = Aws::String>
  void SetLakehouseIdcApplicationArn(LakehouseIdcApplicationArnT&& value) {
    m_lakehouseIdcApplicationArnHasBeenSet = true;
    m_lakehouseIdcApplicationArn = std::forward<LakehouseIdcApplicationArnT>(value);
  }
  template <typename LakehouseIdcApplicationArnT = Aws::String>
  ModifyLakehouseConfigurationRequest& WithLakehouseIdcApplicationArn(LakehouseIdcApplicationArnT&& value) {
    SetLakehouseIdcApplicationArn(std::forward<LakehouseIdcApplicationArnT>(value));
    return *this;
  }
 
 
  inline bool GetDryRun() const { return m_dryRun; }
  inline bool DryRunHasBeenSet() const { return m_dryRunHasBeenSet; }
  inline void SetDryRun(bool value) {
    m_dryRunHasBeenSet = true;
    m_dryRun = value;
  }
  inline ModifyLakehouseConfigurationRequest& WithDryRun(bool value) {
    SetDryRun(value);
    return *this;
  }
 private:
  Aws::String m_clusterIdentifier;
 
  LakehouseRegistration m_lakehouseRegistration{LakehouseRegistration::NOT_SET};
 
  Aws::String m_catalogName;
 
  LakehouseIdcRegistration m_lakehouseIdcRegistration{LakehouseIdcRegistration::NOT_SET};
 
  Aws::String m_lakehouseIdcApplicationArn;
 
  bool m_dryRun{false};
  bool m_clusterIdentifierHasBeenSet = false;
  bool m_lakehouseRegistrationHasBeenSet = false;
  bool m_catalogNameHasBeenSet = false;
  bool m_lakehouseIdcRegistrationHasBeenSet = false;
  bool m_lakehouseIdcApplicationArnHasBeenSet = false;
  bool m_dryRunHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Redshift
}  // namespace Aws