ConnectionPropertiesPatch.h

 
#pragma once
#include <aws/datazone/DataZone_EXPORTS.h>
#include <aws/datazone/model/AmazonQPropertiesPatch.h>
#include <aws/datazone/model/AthenaPropertiesPatch.h>
#include <aws/datazone/model/GitPropertiesPatch.h>
#include <aws/datazone/model/GluePropertiesPatch.h>
#include <aws/datazone/model/IamPropertiesPatch.h>
#include <aws/datazone/model/LakehousePropertiesPatch.h>
#include <aws/datazone/model/MlflowPropertiesPatch.h>
#include <aws/datazone/model/RedshiftPropertiesPatch.h>
#include <aws/datazone/model/S3PropertiesPatch.h>
#include <aws/datazone/model/SnowflakePropertiesPatch.h>
#include <aws/datazone/model/SparkEmrPropertiesPatch.h>
#include <aws/datazone/model/VpcPropertiesPatch.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace DataZone {
namespace Model {
 
class ConnectionPropertiesPatch {
 public:
  AWS_DATAZONE_API ConnectionPropertiesPatch() = default;
  AWS_DATAZONE_API ConnectionPropertiesPatch(Aws::Utils::Json::JsonView jsonValue);
  AWS_DATAZONE_API ConnectionPropertiesPatch& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_DATAZONE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const AthenaPropertiesPatch& GetAthenaProperties() const { return m_athenaProperties; }
  inline bool AthenaPropertiesHasBeenSet() const { return m_athenaPropertiesHasBeenSet; }
  template <typename AthenaPropertiesT = AthenaPropertiesPatch>
  void SetAthenaProperties(AthenaPropertiesT&& value) {
    m_athenaPropertiesHasBeenSet = true;
    m_athenaProperties = std::forward<AthenaPropertiesT>(value);
  }
  template <typename AthenaPropertiesT = AthenaPropertiesPatch>
  ConnectionPropertiesPatch& WithAthenaProperties(AthenaPropertiesT&& value) {
    SetAthenaProperties(std::forward<AthenaPropertiesT>(value));
    return *this;
  }
 
 
  inline const GluePropertiesPatch& GetGlueProperties() const { return m_glueProperties; }
  inline bool GluePropertiesHasBeenSet() const { return m_gluePropertiesHasBeenSet; }
  template <typename GluePropertiesT = GluePropertiesPatch>
  void SetGlueProperties(GluePropertiesT&& value) {
    m_gluePropertiesHasBeenSet = true;
    m_glueProperties = std::forward<GluePropertiesT>(value);
  }
  template <typename GluePropertiesT = GluePropertiesPatch>
  ConnectionPropertiesPatch& WithGlueProperties(GluePropertiesT&& value) {
    SetGlueProperties(std::forward<GluePropertiesT>(value));
    return *this;
  }
 
 
  inline const IamPropertiesPatch& GetIamProperties() const { return m_iamProperties; }
  inline bool IamPropertiesHasBeenSet() const { return m_iamPropertiesHasBeenSet; }
  template <typename IamPropertiesT = IamPropertiesPatch>
  void SetIamProperties(IamPropertiesT&& value) {
    m_iamPropertiesHasBeenSet = true;
    m_iamProperties = std::forward<IamPropertiesT>(value);
  }
  template <typename IamPropertiesT = IamPropertiesPatch>
  ConnectionPropertiesPatch& WithIamProperties(IamPropertiesT&& value) {
    SetIamProperties(std::forward<IamPropertiesT>(value));
    return *this;
  }
 
 
  inline const RedshiftPropertiesPatch& GetRedshiftProperties() const { return m_redshiftProperties; }
  inline bool RedshiftPropertiesHasBeenSet() const { return m_redshiftPropertiesHasBeenSet; }
  template <typename RedshiftPropertiesT = RedshiftPropertiesPatch>
  void SetRedshiftProperties(RedshiftPropertiesT&& value) {
    m_redshiftPropertiesHasBeenSet = true;
    m_redshiftProperties = std::forward<RedshiftPropertiesT>(value);
  }
  template <typename RedshiftPropertiesT = RedshiftPropertiesPatch>
  ConnectionPropertiesPatch& WithRedshiftProperties(RedshiftPropertiesT&& value) {
    SetRedshiftProperties(std::forward<RedshiftPropertiesT>(value));
    return *this;
  }
 
 
  inline const SparkEmrPropertiesPatch& GetSparkEmrProperties() const { return m_sparkEmrProperties; }
  inline bool SparkEmrPropertiesHasBeenSet() const { return m_sparkEmrPropertiesHasBeenSet; }
  template <typename SparkEmrPropertiesT = SparkEmrPropertiesPatch>
  void SetSparkEmrProperties(SparkEmrPropertiesT&& value) {
    m_sparkEmrPropertiesHasBeenSet = true;
    m_sparkEmrProperties = std::forward<SparkEmrPropertiesT>(value);
  }
  template <typename SparkEmrPropertiesT = SparkEmrPropertiesPatch>
  ConnectionPropertiesPatch& WithSparkEmrProperties(SparkEmrPropertiesT&& value) {
    SetSparkEmrProperties(std::forward<SparkEmrPropertiesT>(value));
    return *this;
  }
 
 
  inline const S3PropertiesPatch& GetS3Properties() const { return m_s3Properties; }
  inline bool S3PropertiesHasBeenSet() const { return m_s3PropertiesHasBeenSet; }
  template <typename S3PropertiesT = S3PropertiesPatch>
  void SetS3Properties(S3PropertiesT&& value) {
    m_s3PropertiesHasBeenSet = true;
    m_s3Properties = std::forward<S3PropertiesT>(value);
  }
  template <typename S3PropertiesT = S3PropertiesPatch>
  ConnectionPropertiesPatch& WithS3Properties(S3PropertiesT&& value) {
    SetS3Properties(std::forward<S3PropertiesT>(value));
    return *this;
  }
 
 
  inline const SnowflakePropertiesPatch& GetSnowflakeProperties() const { return m_snowflakeProperties; }
  inline bool SnowflakePropertiesHasBeenSet() const { return m_snowflakePropertiesHasBeenSet; }
  template <typename SnowflakePropertiesT = SnowflakePropertiesPatch>
  void SetSnowflakeProperties(SnowflakePropertiesT&& value) {
    m_snowflakePropertiesHasBeenSet = true;
    m_snowflakeProperties = std::forward<SnowflakePropertiesT>(value);
  }
  template <typename SnowflakePropertiesT = SnowflakePropertiesPatch>
  ConnectionPropertiesPatch& WithSnowflakeProperties(SnowflakePropertiesT&& value) {
    SetSnowflakeProperties(std::forward<SnowflakePropertiesT>(value));
    return *this;
  }
 
 
  inline const AmazonQPropertiesPatch& GetAmazonQProperties() const { return m_amazonQProperties; }
  inline bool AmazonQPropertiesHasBeenSet() const { return m_amazonQPropertiesHasBeenSet; }
  template <typename AmazonQPropertiesT = AmazonQPropertiesPatch>
  void SetAmazonQProperties(AmazonQPropertiesT&& value) {
    m_amazonQPropertiesHasBeenSet = true;
    m_amazonQProperties = std::forward<AmazonQPropertiesT>(value);
  }
  template <typename AmazonQPropertiesT = AmazonQPropertiesPatch>
  ConnectionPropertiesPatch& WithAmazonQProperties(AmazonQPropertiesT&& value) {
    SetAmazonQProperties(std::forward<AmazonQPropertiesT>(value));
    return *this;
  }
 
 
  inline const MlflowPropertiesPatch& GetMlflowProperties() const { return m_mlflowProperties; }
  inline bool MlflowPropertiesHasBeenSet() const { return m_mlflowPropertiesHasBeenSet; }
  template <typename MlflowPropertiesT = MlflowPropertiesPatch>
  void SetMlflowProperties(MlflowPropertiesT&& value) {
    m_mlflowPropertiesHasBeenSet = true;
    m_mlflowProperties = std::forward<MlflowPropertiesT>(value);
  }
  template <typename MlflowPropertiesT = MlflowPropertiesPatch>
  ConnectionPropertiesPatch& WithMlflowProperties(MlflowPropertiesT&& value) {
    SetMlflowProperties(std::forward<MlflowPropertiesT>(value));
    return *this;
  }
 
 
  inline const LakehousePropertiesPatch& GetLakehouseProperties() const { return m_lakehouseProperties; }
  inline bool LakehousePropertiesHasBeenSet() const { return m_lakehousePropertiesHasBeenSet; }
  template <typename LakehousePropertiesT = LakehousePropertiesPatch>
  void SetLakehouseProperties(LakehousePropertiesT&& value) {
    m_lakehousePropertiesHasBeenSet = true;
    m_lakehouseProperties = std::forward<LakehousePropertiesT>(value);
  }
  template <typename LakehousePropertiesT = LakehousePropertiesPatch>
  ConnectionPropertiesPatch& WithLakehouseProperties(LakehousePropertiesT&& value) {
    SetLakehouseProperties(std::forward<LakehousePropertiesT>(value));
    return *this;
  }
 
 
  inline const VpcPropertiesPatch& GetVpcProperties() const { return m_vpcProperties; }
  inline bool VpcPropertiesHasBeenSet() const { return m_vpcPropertiesHasBeenSet; }
  template <typename VpcPropertiesT = VpcPropertiesPatch>
  void SetVpcProperties(VpcPropertiesT&& value) {
    m_vpcPropertiesHasBeenSet = true;
    m_vpcProperties = std::forward<VpcPropertiesT>(value);
  }
  template <typename VpcPropertiesT = VpcPropertiesPatch>
  ConnectionPropertiesPatch& WithVpcProperties(VpcPropertiesT&& value) {
    SetVpcProperties(std::forward<VpcPropertiesT>(value));
    return *this;
  }
 
 
  inline const GitPropertiesPatch& GetGitProperties() const { return m_gitProperties; }
  inline bool GitPropertiesHasBeenSet() const { return m_gitPropertiesHasBeenSet; }
  template <typename GitPropertiesT = GitPropertiesPatch>
  void SetGitProperties(GitPropertiesT&& value) {
    m_gitPropertiesHasBeenSet = true;
    m_gitProperties = std::forward<GitPropertiesT>(value);
  }
  template <typename GitPropertiesT = GitPropertiesPatch>
  ConnectionPropertiesPatch& WithGitProperties(GitPropertiesT&& value) {
    SetGitProperties(std::forward<GitPropertiesT>(value));
    return *this;
  }
 private:
  AthenaPropertiesPatch m_athenaProperties;
 
  GluePropertiesPatch m_glueProperties;
 
  IamPropertiesPatch m_iamProperties;
 
  RedshiftPropertiesPatch m_redshiftProperties;
 
  SparkEmrPropertiesPatch m_sparkEmrProperties;
 
  S3PropertiesPatch m_s3Properties;
 
  SnowflakePropertiesPatch m_snowflakeProperties;
 
  AmazonQPropertiesPatch m_amazonQProperties;
 
  MlflowPropertiesPatch m_mlflowProperties;
 
  LakehousePropertiesPatch m_lakehouseProperties;
 
  VpcPropertiesPatch m_vpcProperties;
 
  GitPropertiesPatch m_gitProperties;
  bool m_athenaPropertiesHasBeenSet = false;
  bool m_gluePropertiesHasBeenSet = false;
  bool m_iamPropertiesHasBeenSet = false;
  bool m_redshiftPropertiesHasBeenSet = false;
  bool m_sparkEmrPropertiesHasBeenSet = false;
  bool m_s3PropertiesHasBeenSet = false;
  bool m_snowflakePropertiesHasBeenSet = false;
  bool m_amazonQPropertiesHasBeenSet = false;
  bool m_mlflowPropertiesHasBeenSet = false;
  bool m_lakehousePropertiesHasBeenSet = false;
  bool m_vpcPropertiesHasBeenSet = false;
  bool m_gitPropertiesHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace DataZone
}  // namespace Aws