CodeGenConfigurationNode.h

 
#pragma once
#include <aws/glue/Glue_EXPORTS.h>
#include <aws/glue/model/Aggregate.h>
#include <aws/glue/model/AmazonRedshiftSource.h>
#include <aws/glue/model/AmazonRedshiftTarget.h>
#include <aws/glue/model/ApplyMapping.h>
#include <aws/glue/model/AthenaConnectorSource.h>
#include <aws/glue/model/BasicCatalogTarget.h>
#include <aws/glue/model/CatalogDeltaSource.h>
#include <aws/glue/model/CatalogHudiSource.h>
#include <aws/glue/model/CatalogIcebergSource.h>
#include <aws/glue/model/CatalogKafkaSource.h>
#include <aws/glue/model/CatalogKinesisSource.h>
#include <aws/glue/model/CatalogSource.h>
#include <aws/glue/model/ConnectorDataSource.h>
#include <aws/glue/model/ConnectorDataTarget.h>
#include <aws/glue/model/CustomCode.h>
#include <aws/glue/model/DirectJDBCSource.h>
#include <aws/glue/model/DirectKafkaSource.h>
#include <aws/glue/model/DirectKinesisSource.h>
#include <aws/glue/model/DropDuplicates.h>
#include <aws/glue/model/DropFields.h>
#include <aws/glue/model/DropNullFields.h>
#include <aws/glue/model/DynamicTransform.h>
#include <aws/glue/model/DynamoDBCatalogSource.h>
#include <aws/glue/model/DynamoDBELTConnectorSource.h>
#include <aws/glue/model/EvaluateDataQuality.h>
#include <aws/glue/model/EvaluateDataQualityMultiFrame.h>
#include <aws/glue/model/FillMissingValues.h>
#include <aws/glue/model/Filter.h>
#include <aws/glue/model/GovernedCatalogSource.h>
#include <aws/glue/model/GovernedCatalogTarget.h>
#include <aws/glue/model/JDBCConnectorSource.h>
#include <aws/glue/model/JDBCConnectorTarget.h>
#include <aws/glue/model/Join.h>
#include <aws/glue/model/Merge.h>
#include <aws/glue/model/MicrosoftSQLServerCatalogSource.h>
#include <aws/glue/model/MicrosoftSQLServerCatalogTarget.h>
#include <aws/glue/model/MySQLCatalogSource.h>
#include <aws/glue/model/MySQLCatalogTarget.h>
#include <aws/glue/model/OracleSQLCatalogSource.h>
#include <aws/glue/model/OracleSQLCatalogTarget.h>
#include <aws/glue/model/PIIDetection.h>
#include <aws/glue/model/PostgreSQLCatalogSource.h>
#include <aws/glue/model/PostgreSQLCatalogTarget.h>
#include <aws/glue/model/Recipe.h>
#include <aws/glue/model/RedshiftSource.h>
#include <aws/glue/model/RedshiftTarget.h>
#include <aws/glue/model/RelationalCatalogSource.h>
#include <aws/glue/model/RenameField.h>
#include <aws/glue/model/Route.h>
#include <aws/glue/model/S3CatalogDeltaSource.h>
#include <aws/glue/model/S3CatalogHudiSource.h>
#include <aws/glue/model/S3CatalogIcebergSource.h>
#include <aws/glue/model/S3CatalogSource.h>
#include <aws/glue/model/S3CatalogTarget.h>
#include <aws/glue/model/S3CsvSource.h>
#include <aws/glue/model/S3DeltaCatalogTarget.h>
#include <aws/glue/model/S3DeltaDirectTarget.h>
#include <aws/glue/model/S3DeltaSource.h>
#include <aws/glue/model/S3DirectTarget.h>
#include <aws/glue/model/S3ExcelSource.h>
#include <aws/glue/model/S3GlueParquetTarget.h>
#include <aws/glue/model/S3HudiCatalogTarget.h>
#include <aws/glue/model/S3HudiDirectTarget.h>
#include <aws/glue/model/S3HudiSource.h>
#include <aws/glue/model/S3HyperDirectTarget.h>
#include <aws/glue/model/S3IcebergCatalogTarget.h>
#include <aws/glue/model/S3IcebergDirectTarget.h>
#include <aws/glue/model/S3JsonSource.h>
#include <aws/glue/model/S3ParquetSource.h>
#include <aws/glue/model/SelectFields.h>
#include <aws/glue/model/SelectFromCollection.h>
#include <aws/glue/model/SnowflakeSource.h>
#include <aws/glue/model/SnowflakeTarget.h>
#include <aws/glue/model/SparkConnectorSource.h>
#include <aws/glue/model/SparkConnectorTarget.h>
#include <aws/glue/model/SparkSQL.h>
#include <aws/glue/model/Spigot.h>
#include <aws/glue/model/SplitFields.h>
#include <aws/glue/model/Union.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Glue {
namespace Model {
 
class CodeGenConfigurationNode {
 public:
  AWS_GLUE_API CodeGenConfigurationNode() = default;
  AWS_GLUE_API CodeGenConfigurationNode(Aws::Utils::Json::JsonView jsonValue);
  AWS_GLUE_API CodeGenConfigurationNode& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_GLUE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const AthenaConnectorSource& GetAthenaConnectorSource() const { return m_athenaConnectorSource; }
  inline bool AthenaConnectorSourceHasBeenSet() const { return m_athenaConnectorSourceHasBeenSet; }
  template <typename AthenaConnectorSourceT = AthenaConnectorSource>
  void SetAthenaConnectorSource(AthenaConnectorSourceT&& value) {
    m_athenaConnectorSourceHasBeenSet = true;
    m_athenaConnectorSource = std::forward<AthenaConnectorSourceT>(value);
  }
  template <typename AthenaConnectorSourceT = AthenaConnectorSource>
  CodeGenConfigurationNode& WithAthenaConnectorSource(AthenaConnectorSourceT&& value) {
    SetAthenaConnectorSource(std::forward<AthenaConnectorSourceT>(value));
    return *this;
  }
 
 
  inline const JDBCConnectorSource& GetJDBCConnectorSource() const { return m_jDBCConnectorSource; }
  inline bool JDBCConnectorSourceHasBeenSet() const { return m_jDBCConnectorSourceHasBeenSet; }
  template <typename JDBCConnectorSourceT = JDBCConnectorSource>
  void SetJDBCConnectorSource(JDBCConnectorSourceT&& value) {
    m_jDBCConnectorSourceHasBeenSet = true;
    m_jDBCConnectorSource = std::forward<JDBCConnectorSourceT>(value);
  }
  template <typename JDBCConnectorSourceT = JDBCConnectorSource>
  CodeGenConfigurationNode& WithJDBCConnectorSource(JDBCConnectorSourceT&& value) {
    SetJDBCConnectorSource(std::forward<JDBCConnectorSourceT>(value));
    return *this;
  }
 
 
  inline const SparkConnectorSource& GetSparkConnectorSource() const { return m_sparkConnectorSource; }
  inline bool SparkConnectorSourceHasBeenSet() const { return m_sparkConnectorSourceHasBeenSet; }
  template <typename SparkConnectorSourceT = SparkConnectorSource>
  void SetSparkConnectorSource(SparkConnectorSourceT&& value) {
    m_sparkConnectorSourceHasBeenSet = true;
    m_sparkConnectorSource = std::forward<SparkConnectorSourceT>(value);
  }
  template <typename SparkConnectorSourceT = SparkConnectorSource>
  CodeGenConfigurationNode& WithSparkConnectorSource(SparkConnectorSourceT&& value) {
    SetSparkConnectorSource(std::forward<SparkConnectorSourceT>(value));
    return *this;
  }
 
 
  inline const CatalogSource& GetCatalogSource() const { return m_catalogSource; }
  inline bool CatalogSourceHasBeenSet() const { return m_catalogSourceHasBeenSet; }
  template <typename CatalogSourceT = CatalogSource>
  void SetCatalogSource(CatalogSourceT&& value) {
    m_catalogSourceHasBeenSet = true;
    m_catalogSource = std::forward<CatalogSourceT>(value);
  }
  template <typename CatalogSourceT = CatalogSource>
  CodeGenConfigurationNode& WithCatalogSource(CatalogSourceT&& value) {
    SetCatalogSource(std::forward<CatalogSourceT>(value));
    return *this;
  }
 
 
  inline const RedshiftSource& GetRedshiftSource() const { return m_redshiftSource; }
  inline bool RedshiftSourceHasBeenSet() const { return m_redshiftSourceHasBeenSet; }
  template <typename RedshiftSourceT = RedshiftSource>
  void SetRedshiftSource(RedshiftSourceT&& value) {
    m_redshiftSourceHasBeenSet = true;
    m_redshiftSource = std::forward<RedshiftSourceT>(value);
  }
  template <typename RedshiftSourceT = RedshiftSource>
  CodeGenConfigurationNode& WithRedshiftSource(RedshiftSourceT&& value) {
    SetRedshiftSource(std::forward<RedshiftSourceT>(value));
    return *this;
  }
 
 
  inline const S3CatalogSource& GetS3CatalogSource() const { return m_s3CatalogSource; }
  inline bool S3CatalogSourceHasBeenSet() const { return m_s3CatalogSourceHasBeenSet; }
  template <typename S3CatalogSourceT = S3CatalogSource>
  void SetS3CatalogSource(S3CatalogSourceT&& value) {
    m_s3CatalogSourceHasBeenSet = true;
    m_s3CatalogSource = std::forward<S3CatalogSourceT>(value);
  }
  template <typename S3CatalogSourceT = S3CatalogSource>
  CodeGenConfigurationNode& WithS3CatalogSource(S3CatalogSourceT&& value) {
    SetS3CatalogSource(std::forward<S3CatalogSourceT>(value));
    return *this;
  }
 
 
  inline const S3CsvSource& GetS3CsvSource() const { return m_s3CsvSource; }
  inline bool S3CsvSourceHasBeenSet() const { return m_s3CsvSourceHasBeenSet; }
  template <typename S3CsvSourceT = S3CsvSource>
  void SetS3CsvSource(S3CsvSourceT&& value) {
    m_s3CsvSourceHasBeenSet = true;
    m_s3CsvSource = std::forward<S3CsvSourceT>(value);
  }
  template <typename S3CsvSourceT = S3CsvSource>
  CodeGenConfigurationNode& WithS3CsvSource(S3CsvSourceT&& value) {
    SetS3CsvSource(std::forward<S3CsvSourceT>(value));
    return *this;
  }
 
 
  inline const S3JsonSource& GetS3JsonSource() const { return m_s3JsonSource; }
  inline bool S3JsonSourceHasBeenSet() const { return m_s3JsonSourceHasBeenSet; }
  template <typename S3JsonSourceT = S3JsonSource>
  void SetS3JsonSource(S3JsonSourceT&& value) {
    m_s3JsonSourceHasBeenSet = true;
    m_s3JsonSource = std::forward<S3JsonSourceT>(value);
  }
  template <typename S3JsonSourceT = S3JsonSource>
  CodeGenConfigurationNode& WithS3JsonSource(S3JsonSourceT&& value) {
    SetS3JsonSource(std::forward<S3JsonSourceT>(value));
    return *this;
  }
 
 
  inline const S3ParquetSource& GetS3ParquetSource() const { return m_s3ParquetSource; }
  inline bool S3ParquetSourceHasBeenSet() const { return m_s3ParquetSourceHasBeenSet; }
  template <typename S3ParquetSourceT = S3ParquetSource>
  void SetS3ParquetSource(S3ParquetSourceT&& value) {
    m_s3ParquetSourceHasBeenSet = true;
    m_s3ParquetSource = std::forward<S3ParquetSourceT>(value);
  }
  template <typename S3ParquetSourceT = S3ParquetSource>
  CodeGenConfigurationNode& WithS3ParquetSource(S3ParquetSourceT&& value) {
    SetS3ParquetSource(std::forward<S3ParquetSourceT>(value));
    return *this;
  }
 
 
  inline const RelationalCatalogSource& GetRelationalCatalogSource() const { return m_relationalCatalogSource; }
  inline bool RelationalCatalogSourceHasBeenSet() const { return m_relationalCatalogSourceHasBeenSet; }
  template <typename RelationalCatalogSourceT = RelationalCatalogSource>
  void SetRelationalCatalogSource(RelationalCatalogSourceT&& value) {
    m_relationalCatalogSourceHasBeenSet = true;
    m_relationalCatalogSource = std::forward<RelationalCatalogSourceT>(value);
  }
  template <typename RelationalCatalogSourceT = RelationalCatalogSource>
  CodeGenConfigurationNode& WithRelationalCatalogSource(RelationalCatalogSourceT&& value) {
    SetRelationalCatalogSource(std::forward<RelationalCatalogSourceT>(value));
    return *this;
  }
 
 
  inline const DynamoDBCatalogSource& GetDynamoDBCatalogSource() const { return m_dynamoDBCatalogSource; }
  inline bool DynamoDBCatalogSourceHasBeenSet() const { return m_dynamoDBCatalogSourceHasBeenSet; }
  template <typename DynamoDBCatalogSourceT = DynamoDBCatalogSource>
  void SetDynamoDBCatalogSource(DynamoDBCatalogSourceT&& value) {
    m_dynamoDBCatalogSourceHasBeenSet = true;
    m_dynamoDBCatalogSource = std::forward<DynamoDBCatalogSourceT>(value);
  }
  template <typename DynamoDBCatalogSourceT = DynamoDBCatalogSource>
  CodeGenConfigurationNode& WithDynamoDBCatalogSource(DynamoDBCatalogSourceT&& value) {
    SetDynamoDBCatalogSource(std::forward<DynamoDBCatalogSourceT>(value));
    return *this;
  }
 
 
  inline const JDBCConnectorTarget& GetJDBCConnectorTarget() const { return m_jDBCConnectorTarget; }
  inline bool JDBCConnectorTargetHasBeenSet() const { return m_jDBCConnectorTargetHasBeenSet; }
  template <typename JDBCConnectorTargetT = JDBCConnectorTarget>
  void SetJDBCConnectorTarget(JDBCConnectorTargetT&& value) {
    m_jDBCConnectorTargetHasBeenSet = true;
    m_jDBCConnectorTarget = std::forward<JDBCConnectorTargetT>(value);
  }
  template <typename JDBCConnectorTargetT = JDBCConnectorTarget>
  CodeGenConfigurationNode& WithJDBCConnectorTarget(JDBCConnectorTargetT&& value) {
    SetJDBCConnectorTarget(std::forward<JDBCConnectorTargetT>(value));
    return *this;
  }
 
 
  inline const SparkConnectorTarget& GetSparkConnectorTarget() const { return m_sparkConnectorTarget; }
  inline bool SparkConnectorTargetHasBeenSet() const { return m_sparkConnectorTargetHasBeenSet; }
  template <typename SparkConnectorTargetT = SparkConnectorTarget>
  void SetSparkConnectorTarget(SparkConnectorTargetT&& value) {
    m_sparkConnectorTargetHasBeenSet = true;
    m_sparkConnectorTarget = std::forward<SparkConnectorTargetT>(value);
  }
  template <typename SparkConnectorTargetT = SparkConnectorTarget>
  CodeGenConfigurationNode& WithSparkConnectorTarget(SparkConnectorTargetT&& value) {
    SetSparkConnectorTarget(std::forward<SparkConnectorTargetT>(value));
    return *this;
  }
 
 
  inline const BasicCatalogTarget& GetCatalogTarget() const { return m_catalogTarget; }
  inline bool CatalogTargetHasBeenSet() const { return m_catalogTargetHasBeenSet; }
  template <typename CatalogTargetT = BasicCatalogTarget>
  void SetCatalogTarget(CatalogTargetT&& value) {
    m_catalogTargetHasBeenSet = true;
    m_catalogTarget = std::forward<CatalogTargetT>(value);
  }
  template <typename CatalogTargetT = BasicCatalogTarget>
  CodeGenConfigurationNode& WithCatalogTarget(CatalogTargetT&& value) {
    SetCatalogTarget(std::forward<CatalogTargetT>(value));
    return *this;
  }
 
 
  inline const RedshiftTarget& GetRedshiftTarget() const { return m_redshiftTarget; }
  inline bool RedshiftTargetHasBeenSet() const { return m_redshiftTargetHasBeenSet; }
  template <typename RedshiftTargetT = RedshiftTarget>
  void SetRedshiftTarget(RedshiftTargetT&& value) {
    m_redshiftTargetHasBeenSet = true;
    m_redshiftTarget = std::forward<RedshiftTargetT>(value);
  }
  template <typename RedshiftTargetT = RedshiftTarget>
  CodeGenConfigurationNode& WithRedshiftTarget(RedshiftTargetT&& value) {
    SetRedshiftTarget(std::forward<RedshiftTargetT>(value));
    return *this;
  }
 
 
  inline const S3CatalogTarget& GetS3CatalogTarget() const { return m_s3CatalogTarget; }
  inline bool S3CatalogTargetHasBeenSet() const { return m_s3CatalogTargetHasBeenSet; }
  template <typename S3CatalogTargetT = S3CatalogTarget>
  void SetS3CatalogTarget(S3CatalogTargetT&& value) {
    m_s3CatalogTargetHasBeenSet = true;
    m_s3CatalogTarget = std::forward<S3CatalogTargetT>(value);
  }
  template <typename S3CatalogTargetT = S3CatalogTarget>
  CodeGenConfigurationNode& WithS3CatalogTarget(S3CatalogTargetT&& value) {
    SetS3CatalogTarget(std::forward<S3CatalogTargetT>(value));
    return *this;
  }
 
 
  inline const S3GlueParquetTarget& GetS3GlueParquetTarget() const { return m_s3GlueParquetTarget; }
  inline bool S3GlueParquetTargetHasBeenSet() const { return m_s3GlueParquetTargetHasBeenSet; }
  template <typename S3GlueParquetTargetT = S3GlueParquetTarget>
  void SetS3GlueParquetTarget(S3GlueParquetTargetT&& value) {
    m_s3GlueParquetTargetHasBeenSet = true;
    m_s3GlueParquetTarget = std::forward<S3GlueParquetTargetT>(value);
  }
  template <typename S3GlueParquetTargetT = S3GlueParquetTarget>
  CodeGenConfigurationNode& WithS3GlueParquetTarget(S3GlueParquetTargetT&& value) {
    SetS3GlueParquetTarget(std::forward<S3GlueParquetTargetT>(value));
    return *this;
  }
 
 
  inline const S3DirectTarget& GetS3DirectTarget() const { return m_s3DirectTarget; }
  inline bool S3DirectTargetHasBeenSet() const { return m_s3DirectTargetHasBeenSet; }
  template <typename S3DirectTargetT = S3DirectTarget>
  void SetS3DirectTarget(S3DirectTargetT&& value) {
    m_s3DirectTargetHasBeenSet = true;
    m_s3DirectTarget = std::forward<S3DirectTargetT>(value);
  }
  template <typename S3DirectTargetT = S3DirectTarget>
  CodeGenConfigurationNode& WithS3DirectTarget(S3DirectTargetT&& value) {
    SetS3DirectTarget(std::forward<S3DirectTargetT>(value));
    return *this;
  }
 
 
  inline const ApplyMapping& GetApplyMapping() const { return m_applyMapping; }
  inline bool ApplyMappingHasBeenSet() const { return m_applyMappingHasBeenSet; }
  template <typename ApplyMappingT = ApplyMapping>
  void SetApplyMapping(ApplyMappingT&& value) {
    m_applyMappingHasBeenSet = true;
    m_applyMapping = std::forward<ApplyMappingT>(value);
  }
  template <typename ApplyMappingT = ApplyMapping>
  CodeGenConfigurationNode& WithApplyMapping(ApplyMappingT&& value) {
    SetApplyMapping(std::forward<ApplyMappingT>(value));
    return *this;
  }
 
 
  inline const SelectFields& GetSelectFields() const { return m_selectFields; }
  inline bool SelectFieldsHasBeenSet() const { return m_selectFieldsHasBeenSet; }
  template <typename SelectFieldsT = SelectFields>
  void SetSelectFields(SelectFieldsT&& value) {
    m_selectFieldsHasBeenSet = true;
    m_selectFields = std::forward<SelectFieldsT>(value);
  }
  template <typename SelectFieldsT = SelectFields>
  CodeGenConfigurationNode& WithSelectFields(SelectFieldsT&& value) {
    SetSelectFields(std::forward<SelectFieldsT>(value));
    return *this;
  }
 
 
  inline const DropFields& GetDropFields() const { return m_dropFields; }
  inline bool DropFieldsHasBeenSet() const { return m_dropFieldsHasBeenSet; }
  template <typename DropFieldsT = DropFields>
  void SetDropFields(DropFieldsT&& value) {
    m_dropFieldsHasBeenSet = true;
    m_dropFields = std::forward<DropFieldsT>(value);
  }
  template <typename DropFieldsT = DropFields>
  CodeGenConfigurationNode& WithDropFields(DropFieldsT&& value) {
    SetDropFields(std::forward<DropFieldsT>(value));
    return *this;
  }
 
 
  inline const RenameField& GetRenameField() const { return m_renameField; }
  inline bool RenameFieldHasBeenSet() const { return m_renameFieldHasBeenSet; }
  template <typename RenameFieldT = RenameField>
  void SetRenameField(RenameFieldT&& value) {
    m_renameFieldHasBeenSet = true;
    m_renameField = std::forward<RenameFieldT>(value);
  }
  template <typename RenameFieldT = RenameField>
  CodeGenConfigurationNode& WithRenameField(RenameFieldT&& value) {
    SetRenameField(std::forward<RenameFieldT>(value));
    return *this;
  }
 
 
  inline const Spigot& GetSpigot() const { return m_spigot; }
  inline bool SpigotHasBeenSet() const { return m_spigotHasBeenSet; }
  template <typename SpigotT = Spigot>
  void SetSpigot(SpigotT&& value) {
    m_spigotHasBeenSet = true;
    m_spigot = std::forward<SpigotT>(value);
  }
  template <typename SpigotT = Spigot>
  CodeGenConfigurationNode& WithSpigot(SpigotT&& value) {
    SetSpigot(std::forward<SpigotT>(value));
    return *this;
  }
 
 
  inline const Join& GetJoin() const { return m_join; }
  inline bool JoinHasBeenSet() const { return m_joinHasBeenSet; }
  template <typename JoinT = Join>
  void SetJoin(JoinT&& value) {
    m_joinHasBeenSet = true;
    m_join = std::forward<JoinT>(value);
  }
  template <typename JoinT = Join>
  CodeGenConfigurationNode& WithJoin(JoinT&& value) {
    SetJoin(std::forward<JoinT>(value));
    return *this;
  }
 
 
  inline const SplitFields& GetSplitFields() const { return m_splitFields; }
  inline bool SplitFieldsHasBeenSet() const { return m_splitFieldsHasBeenSet; }
  template <typename SplitFieldsT = SplitFields>
  void SetSplitFields(SplitFieldsT&& value) {
    m_splitFieldsHasBeenSet = true;
    m_splitFields = std::forward<SplitFieldsT>(value);
  }
  template <typename SplitFieldsT = SplitFields>
  CodeGenConfigurationNode& WithSplitFields(SplitFieldsT&& value) {
    SetSplitFields(std::forward<SplitFieldsT>(value));
    return *this;
  }
 
 
  inline const SelectFromCollection& GetSelectFromCollection() const { return m_selectFromCollection; }
  inline bool SelectFromCollectionHasBeenSet() const { return m_selectFromCollectionHasBeenSet; }
  template <typename SelectFromCollectionT = SelectFromCollection>
  void SetSelectFromCollection(SelectFromCollectionT&& value) {
    m_selectFromCollectionHasBeenSet = true;
    m_selectFromCollection = std::forward<SelectFromCollectionT>(value);
  }
  template <typename SelectFromCollectionT = SelectFromCollection>
  CodeGenConfigurationNode& WithSelectFromCollection(SelectFromCollectionT&& value) {
    SetSelectFromCollection(std::forward<SelectFromCollectionT>(value));
    return *this;
  }
 
 
  inline const FillMissingValues& GetFillMissingValues() const { return m_fillMissingValues; }
  inline bool FillMissingValuesHasBeenSet() const { return m_fillMissingValuesHasBeenSet; }
  template <typename FillMissingValuesT = FillMissingValues>
  void SetFillMissingValues(FillMissingValuesT&& value) {
    m_fillMissingValuesHasBeenSet = true;
    m_fillMissingValues = std::forward<FillMissingValuesT>(value);
  }
  template <typename FillMissingValuesT = FillMissingValues>
  CodeGenConfigurationNode& WithFillMissingValues(FillMissingValuesT&& value) {
    SetFillMissingValues(std::forward<FillMissingValuesT>(value));
    return *this;
  }
 
 
  inline const Filter& GetFilter() const { return m_filter; }
  inline bool FilterHasBeenSet() const { return m_filterHasBeenSet; }
  template <typename FilterT = Filter>
  void SetFilter(FilterT&& value) {
    m_filterHasBeenSet = true;
    m_filter = std::forward<FilterT>(value);
  }
  template <typename FilterT = Filter>
  CodeGenConfigurationNode& WithFilter(FilterT&& value) {
    SetFilter(std::forward<FilterT>(value));
    return *this;
  }
 
 
  inline const CustomCode& GetCustomCode() const { return m_customCode; }
  inline bool CustomCodeHasBeenSet() const { return m_customCodeHasBeenSet; }
  template <typename CustomCodeT = CustomCode>
  void SetCustomCode(CustomCodeT&& value) {
    m_customCodeHasBeenSet = true;
    m_customCode = std::forward<CustomCodeT>(value);
  }
  template <typename CustomCodeT = CustomCode>
  CodeGenConfigurationNode& WithCustomCode(CustomCodeT&& value) {
    SetCustomCode(std::forward<CustomCodeT>(value));
    return *this;
  }
 
 
  inline const SparkSQL& GetSparkSQL() const { return m_sparkSQL; }
  inline bool SparkSQLHasBeenSet() const { return m_sparkSQLHasBeenSet; }
  template <typename SparkSQLT = SparkSQL>
  void SetSparkSQL(SparkSQLT&& value) {
    m_sparkSQLHasBeenSet = true;
    m_sparkSQL = std::forward<SparkSQLT>(value);
  }
  template <typename SparkSQLT = SparkSQL>
  CodeGenConfigurationNode& WithSparkSQL(SparkSQLT&& value) {
    SetSparkSQL(std::forward<SparkSQLT>(value));
    return *this;
  }
 
 
  inline const DirectKinesisSource& GetDirectKinesisSource() const { return m_directKinesisSource; }
  inline bool DirectKinesisSourceHasBeenSet() const { return m_directKinesisSourceHasBeenSet; }
  template <typename DirectKinesisSourceT = DirectKinesisSource>
  void SetDirectKinesisSource(DirectKinesisSourceT&& value) {
    m_directKinesisSourceHasBeenSet = true;
    m_directKinesisSource = std::forward<DirectKinesisSourceT>(value);
  }
  template <typename DirectKinesisSourceT = DirectKinesisSource>
  CodeGenConfigurationNode& WithDirectKinesisSource(DirectKinesisSourceT&& value) {
    SetDirectKinesisSource(std::forward<DirectKinesisSourceT>(value));
    return *this;
  }
 
 
  inline const DirectKafkaSource& GetDirectKafkaSource() const { return m_directKafkaSource; }
  inline bool DirectKafkaSourceHasBeenSet() const { return m_directKafkaSourceHasBeenSet; }
  template <typename DirectKafkaSourceT = DirectKafkaSource>
  void SetDirectKafkaSource(DirectKafkaSourceT&& value) {
    m_directKafkaSourceHasBeenSet = true;
    m_directKafkaSource = std::forward<DirectKafkaSourceT>(value);
  }
  template <typename DirectKafkaSourceT = DirectKafkaSource>
  CodeGenConfigurationNode& WithDirectKafkaSource(DirectKafkaSourceT&& value) {
    SetDirectKafkaSource(std::forward<DirectKafkaSourceT>(value));
    return *this;
  }
 
 
  inline const CatalogKinesisSource& GetCatalogKinesisSource() const { return m_catalogKinesisSource; }
  inline bool CatalogKinesisSourceHasBeenSet() const { return m_catalogKinesisSourceHasBeenSet; }
  template <typename CatalogKinesisSourceT = CatalogKinesisSource>
  void SetCatalogKinesisSource(CatalogKinesisSourceT&& value) {
    m_catalogKinesisSourceHasBeenSet = true;
    m_catalogKinesisSource = std::forward<CatalogKinesisSourceT>(value);
  }
  template <typename CatalogKinesisSourceT = CatalogKinesisSource>
  CodeGenConfigurationNode& WithCatalogKinesisSource(CatalogKinesisSourceT&& value) {
    SetCatalogKinesisSource(std::forward<CatalogKinesisSourceT>(value));
    return *this;
  }
 
 
  inline const CatalogKafkaSource& GetCatalogKafkaSource() const { return m_catalogKafkaSource; }
  inline bool CatalogKafkaSourceHasBeenSet() const { return m_catalogKafkaSourceHasBeenSet; }
  template <typename CatalogKafkaSourceT = CatalogKafkaSource>
  void SetCatalogKafkaSource(CatalogKafkaSourceT&& value) {
    m_catalogKafkaSourceHasBeenSet = true;
    m_catalogKafkaSource = std::forward<CatalogKafkaSourceT>(value);
  }
  template <typename CatalogKafkaSourceT = CatalogKafkaSource>
  CodeGenConfigurationNode& WithCatalogKafkaSource(CatalogKafkaSourceT&& value) {
    SetCatalogKafkaSource(std::forward<CatalogKafkaSourceT>(value));
    return *this;
  }
 
 
  inline const DropNullFields& GetDropNullFields() const { return m_dropNullFields; }
  inline bool DropNullFieldsHasBeenSet() const { return m_dropNullFieldsHasBeenSet; }
  template <typename DropNullFieldsT = DropNullFields>
  void SetDropNullFields(DropNullFieldsT&& value) {
    m_dropNullFieldsHasBeenSet = true;
    m_dropNullFields = std::forward<DropNullFieldsT>(value);
  }
  template <typename DropNullFieldsT = DropNullFields>
  CodeGenConfigurationNode& WithDropNullFields(DropNullFieldsT&& value) {
    SetDropNullFields(std::forward<DropNullFieldsT>(value));
    return *this;
  }
 
 
  inline const Merge& GetMerge() const { return m_merge; }
  inline bool MergeHasBeenSet() const { return m_mergeHasBeenSet; }
  template <typename MergeT = Merge>
  void SetMerge(MergeT&& value) {
    m_mergeHasBeenSet = true;
    m_merge = std::forward<MergeT>(value);
  }
  template <typename MergeT = Merge>
  CodeGenConfigurationNode& WithMerge(MergeT&& value) {
    SetMerge(std::forward<MergeT>(value));
    return *this;
  }
 
 
  inline const Union& GetUnion() const { return m_union; }
  inline bool UnionHasBeenSet() const { return m_unionHasBeenSet; }
  template <typename UnionT = Union>
  void SetUnion(UnionT&& value) {
    m_unionHasBeenSet = true;
    m_union = std::forward<UnionT>(value);
  }
  template <typename UnionT = Union>
  CodeGenConfigurationNode& WithUnion(UnionT&& value) {
    SetUnion(std::forward<UnionT>(value));
    return *this;
  }
 
 
  inline const PIIDetection& GetPIIDetection() const { return m_pIIDetection; }
  inline bool PIIDetectionHasBeenSet() const { return m_pIIDetectionHasBeenSet; }
  template <typename PIIDetectionT = PIIDetection>
  void SetPIIDetection(PIIDetectionT&& value) {
    m_pIIDetectionHasBeenSet = true;
    m_pIIDetection = std::forward<PIIDetectionT>(value);
  }
  template <typename PIIDetectionT = PIIDetection>
  CodeGenConfigurationNode& WithPIIDetection(PIIDetectionT&& value) {
    SetPIIDetection(std::forward<PIIDetectionT>(value));
    return *this;
  }
 
 
  inline const Aggregate& GetAggregate() const { return m_aggregate; }
  inline bool AggregateHasBeenSet() const { return m_aggregateHasBeenSet; }
  template <typename AggregateT = Aggregate>
  void SetAggregate(AggregateT&& value) {
    m_aggregateHasBeenSet = true;
    m_aggregate = std::forward<AggregateT>(value);
  }
  template <typename AggregateT = Aggregate>
  CodeGenConfigurationNode& WithAggregate(AggregateT&& value) {
    SetAggregate(std::forward<AggregateT>(value));
    return *this;
  }
 
 
  inline const DropDuplicates& GetDropDuplicates() const { return m_dropDuplicates; }
  inline bool DropDuplicatesHasBeenSet() const { return m_dropDuplicatesHasBeenSet; }
  template <typename DropDuplicatesT = DropDuplicates>
  void SetDropDuplicates(DropDuplicatesT&& value) {
    m_dropDuplicatesHasBeenSet = true;
    m_dropDuplicates = std::forward<DropDuplicatesT>(value);
  }
  template <typename DropDuplicatesT = DropDuplicates>
  CodeGenConfigurationNode& WithDropDuplicates(DropDuplicatesT&& value) {
    SetDropDuplicates(std::forward<DropDuplicatesT>(value));
    return *this;
  }
 
 
  inline const GovernedCatalogTarget& GetGovernedCatalogTarget() const { return m_governedCatalogTarget; }
  inline bool GovernedCatalogTargetHasBeenSet() const { return m_governedCatalogTargetHasBeenSet; }
  template <typename GovernedCatalogTargetT = GovernedCatalogTarget>
  void SetGovernedCatalogTarget(GovernedCatalogTargetT&& value) {
    m_governedCatalogTargetHasBeenSet = true;
    m_governedCatalogTarget = std::forward<GovernedCatalogTargetT>(value);
  }
  template <typename GovernedCatalogTargetT = GovernedCatalogTarget>
  CodeGenConfigurationNode& WithGovernedCatalogTarget(GovernedCatalogTargetT&& value) {
    SetGovernedCatalogTarget(std::forward<GovernedCatalogTargetT>(value));
    return *this;
  }
 
 
  inline const GovernedCatalogSource& GetGovernedCatalogSource() const { return m_governedCatalogSource; }
  inline bool GovernedCatalogSourceHasBeenSet() const { return m_governedCatalogSourceHasBeenSet; }
  template <typename GovernedCatalogSourceT = GovernedCatalogSource>
  void SetGovernedCatalogSource(GovernedCatalogSourceT&& value) {
    m_governedCatalogSourceHasBeenSet = true;
    m_governedCatalogSource = std::forward<GovernedCatalogSourceT>(value);
  }
  template <typename GovernedCatalogSourceT = GovernedCatalogSource>
  CodeGenConfigurationNode& WithGovernedCatalogSource(GovernedCatalogSourceT&& value) {
    SetGovernedCatalogSource(std::forward<GovernedCatalogSourceT>(value));
    return *this;
  }
 
 
  inline const MicrosoftSQLServerCatalogSource& GetMicrosoftSQLServerCatalogSource() const { return m_microsoftSQLServerCatalogSource; }
  inline bool MicrosoftSQLServerCatalogSourceHasBeenSet() const { return m_microsoftSQLServerCatalogSourceHasBeenSet; }
  template <typename MicrosoftSQLServerCatalogSourceT = MicrosoftSQLServerCatalogSource>
  void SetMicrosoftSQLServerCatalogSource(MicrosoftSQLServerCatalogSourceT&& value) {
    m_microsoftSQLServerCatalogSourceHasBeenSet = true;
    m_microsoftSQLServerCatalogSource = std::forward<MicrosoftSQLServerCatalogSourceT>(value);
  }
  template <typename MicrosoftSQLServerCatalogSourceT = MicrosoftSQLServerCatalogSource>
  CodeGenConfigurationNode& WithMicrosoftSQLServerCatalogSource(MicrosoftSQLServerCatalogSourceT&& value) {
    SetMicrosoftSQLServerCatalogSource(std::forward<MicrosoftSQLServerCatalogSourceT>(value));
    return *this;
  }
 
 
  inline const MySQLCatalogSource& GetMySQLCatalogSource() const { return m_mySQLCatalogSource; }
  inline bool MySQLCatalogSourceHasBeenSet() const { return m_mySQLCatalogSourceHasBeenSet; }
  template <typename MySQLCatalogSourceT = MySQLCatalogSource>
  void SetMySQLCatalogSource(MySQLCatalogSourceT&& value) {
    m_mySQLCatalogSourceHasBeenSet = true;
    m_mySQLCatalogSource = std::forward<MySQLCatalogSourceT>(value);
  }
  template <typename MySQLCatalogSourceT = MySQLCatalogSource>
  CodeGenConfigurationNode& WithMySQLCatalogSource(MySQLCatalogSourceT&& value) {
    SetMySQLCatalogSource(std::forward<MySQLCatalogSourceT>(value));
    return *this;
  }
 
 
  inline const OracleSQLCatalogSource& GetOracleSQLCatalogSource() const { return m_oracleSQLCatalogSource; }
  inline bool OracleSQLCatalogSourceHasBeenSet() const { return m_oracleSQLCatalogSourceHasBeenSet; }
  template <typename OracleSQLCatalogSourceT = OracleSQLCatalogSource>
  void SetOracleSQLCatalogSource(OracleSQLCatalogSourceT&& value) {
    m_oracleSQLCatalogSourceHasBeenSet = true;
    m_oracleSQLCatalogSource = std::forward<OracleSQLCatalogSourceT>(value);
  }
  template <typename OracleSQLCatalogSourceT = OracleSQLCatalogSource>
  CodeGenConfigurationNode& WithOracleSQLCatalogSource(OracleSQLCatalogSourceT&& value) {
    SetOracleSQLCatalogSource(std::forward<OracleSQLCatalogSourceT>(value));
    return *this;
  }
 
 
  inline const PostgreSQLCatalogSource& GetPostgreSQLCatalogSource() const { return m_postgreSQLCatalogSource; }
  inline bool PostgreSQLCatalogSourceHasBeenSet() const { return m_postgreSQLCatalogSourceHasBeenSet; }
  template <typename PostgreSQLCatalogSourceT = PostgreSQLCatalogSource>
  void SetPostgreSQLCatalogSource(PostgreSQLCatalogSourceT&& value) {
    m_postgreSQLCatalogSourceHasBeenSet = true;
    m_postgreSQLCatalogSource = std::forward<PostgreSQLCatalogSourceT>(value);
  }
  template <typename PostgreSQLCatalogSourceT = PostgreSQLCatalogSource>
  CodeGenConfigurationNode& WithPostgreSQLCatalogSource(PostgreSQLCatalogSourceT&& value) {
    SetPostgreSQLCatalogSource(std::forward<PostgreSQLCatalogSourceT>(value));
    return *this;
  }
 
 
  inline const MicrosoftSQLServerCatalogTarget& GetMicrosoftSQLServerCatalogTarget() const { return m_microsoftSQLServerCatalogTarget; }
  inline bool MicrosoftSQLServerCatalogTargetHasBeenSet() const { return m_microsoftSQLServerCatalogTargetHasBeenSet; }
  template <typename MicrosoftSQLServerCatalogTargetT = MicrosoftSQLServerCatalogTarget>
  void SetMicrosoftSQLServerCatalogTarget(MicrosoftSQLServerCatalogTargetT&& value) {
    m_microsoftSQLServerCatalogTargetHasBeenSet = true;
    m_microsoftSQLServerCatalogTarget = std::forward<MicrosoftSQLServerCatalogTargetT>(value);
  }
  template <typename MicrosoftSQLServerCatalogTargetT = MicrosoftSQLServerCatalogTarget>
  CodeGenConfigurationNode& WithMicrosoftSQLServerCatalogTarget(MicrosoftSQLServerCatalogTargetT&& value) {
    SetMicrosoftSQLServerCatalogTarget(std::forward<MicrosoftSQLServerCatalogTargetT>(value));
    return *this;
  }
 
 
  inline const MySQLCatalogTarget& GetMySQLCatalogTarget() const { return m_mySQLCatalogTarget; }
  inline bool MySQLCatalogTargetHasBeenSet() const { return m_mySQLCatalogTargetHasBeenSet; }
  template <typename MySQLCatalogTargetT = MySQLCatalogTarget>
  void SetMySQLCatalogTarget(MySQLCatalogTargetT&& value) {
    m_mySQLCatalogTargetHasBeenSet = true;
    m_mySQLCatalogTarget = std::forward<MySQLCatalogTargetT>(value);
  }
  template <typename MySQLCatalogTargetT = MySQLCatalogTarget>
  CodeGenConfigurationNode& WithMySQLCatalogTarget(MySQLCatalogTargetT&& value) {
    SetMySQLCatalogTarget(std::forward<MySQLCatalogTargetT>(value));
    return *this;
  }
 
 
  inline const OracleSQLCatalogTarget& GetOracleSQLCatalogTarget() const { return m_oracleSQLCatalogTarget; }
  inline bool OracleSQLCatalogTargetHasBeenSet() const { return m_oracleSQLCatalogTargetHasBeenSet; }
  template <typename OracleSQLCatalogTargetT = OracleSQLCatalogTarget>
  void SetOracleSQLCatalogTarget(OracleSQLCatalogTargetT&& value) {
    m_oracleSQLCatalogTargetHasBeenSet = true;
    m_oracleSQLCatalogTarget = std::forward<OracleSQLCatalogTargetT>(value);
  }
  template <typename OracleSQLCatalogTargetT = OracleSQLCatalogTarget>
  CodeGenConfigurationNode& WithOracleSQLCatalogTarget(OracleSQLCatalogTargetT&& value) {
    SetOracleSQLCatalogTarget(std::forward<OracleSQLCatalogTargetT>(value));
    return *this;
  }
 
 
  inline const PostgreSQLCatalogTarget& GetPostgreSQLCatalogTarget() const { return m_postgreSQLCatalogTarget; }
  inline bool PostgreSQLCatalogTargetHasBeenSet() const { return m_postgreSQLCatalogTargetHasBeenSet; }
  template <typename PostgreSQLCatalogTargetT = PostgreSQLCatalogTarget>
  void SetPostgreSQLCatalogTarget(PostgreSQLCatalogTargetT&& value) {
    m_postgreSQLCatalogTargetHasBeenSet = true;
    m_postgreSQLCatalogTarget = std::forward<PostgreSQLCatalogTargetT>(value);
  }
  template <typename PostgreSQLCatalogTargetT = PostgreSQLCatalogTarget>
  CodeGenConfigurationNode& WithPostgreSQLCatalogTarget(PostgreSQLCatalogTargetT&& value) {
    SetPostgreSQLCatalogTarget(std::forward<PostgreSQLCatalogTargetT>(value));
    return *this;
  }
 
 
  inline const Route& GetRoute() const { return m_route; }
  inline bool RouteHasBeenSet() const { return m_routeHasBeenSet; }
  template <typename RouteT = Route>
  void SetRoute(RouteT&& value) {
    m_routeHasBeenSet = true;
    m_route = std::forward<RouteT>(value);
  }
  template <typename RouteT = Route>
  CodeGenConfigurationNode& WithRoute(RouteT&& value) {
    SetRoute(std::forward<RouteT>(value));
    return *this;
  }
 
 
  inline const DynamicTransform& GetDynamicTransform() const { return m_dynamicTransform; }
  inline bool DynamicTransformHasBeenSet() const { return m_dynamicTransformHasBeenSet; }
  template <typename DynamicTransformT = DynamicTransform>
  void SetDynamicTransform(DynamicTransformT&& value) {
    m_dynamicTransformHasBeenSet = true;
    m_dynamicTransform = std::forward<DynamicTransformT>(value);
  }
  template <typename DynamicTransformT = DynamicTransform>
  CodeGenConfigurationNode& WithDynamicTransform(DynamicTransformT&& value) {
    SetDynamicTransform(std::forward<DynamicTransformT>(value));
    return *this;
  }
 
 
  inline const EvaluateDataQuality& GetEvaluateDataQuality() const { return m_evaluateDataQuality; }
  inline bool EvaluateDataQualityHasBeenSet() const { return m_evaluateDataQualityHasBeenSet; }
  template <typename EvaluateDataQualityT = EvaluateDataQuality>
  void SetEvaluateDataQuality(EvaluateDataQualityT&& value) {
    m_evaluateDataQualityHasBeenSet = true;
    m_evaluateDataQuality = std::forward<EvaluateDataQualityT>(value);
  }
  template <typename EvaluateDataQualityT = EvaluateDataQuality>
  CodeGenConfigurationNode& WithEvaluateDataQuality(EvaluateDataQualityT&& value) {
    SetEvaluateDataQuality(std::forward<EvaluateDataQualityT>(value));
    return *this;
  }
 
 
  inline const S3CatalogHudiSource& GetS3CatalogHudiSource() const { return m_s3CatalogHudiSource; }
  inline bool S3CatalogHudiSourceHasBeenSet() const { return m_s3CatalogHudiSourceHasBeenSet; }
  template <typename S3CatalogHudiSourceT = S3CatalogHudiSource>
  void SetS3CatalogHudiSource(S3CatalogHudiSourceT&& value) {
    m_s3CatalogHudiSourceHasBeenSet = true;
    m_s3CatalogHudiSource = std::forward<S3CatalogHudiSourceT>(value);
  }
  template <typename S3CatalogHudiSourceT = S3CatalogHudiSource>
  CodeGenConfigurationNode& WithS3CatalogHudiSource(S3CatalogHudiSourceT&& value) {
    SetS3CatalogHudiSource(std::forward<S3CatalogHudiSourceT>(value));
    return *this;
  }
 
 
  inline const CatalogHudiSource& GetCatalogHudiSource() const { return m_catalogHudiSource; }
  inline bool CatalogHudiSourceHasBeenSet() const { return m_catalogHudiSourceHasBeenSet; }
  template <typename CatalogHudiSourceT = CatalogHudiSource>
  void SetCatalogHudiSource(CatalogHudiSourceT&& value) {
    m_catalogHudiSourceHasBeenSet = true;
    m_catalogHudiSource = std::forward<CatalogHudiSourceT>(value);
  }
  template <typename CatalogHudiSourceT = CatalogHudiSource>
  CodeGenConfigurationNode& WithCatalogHudiSource(CatalogHudiSourceT&& value) {
    SetCatalogHudiSource(std::forward<CatalogHudiSourceT>(value));
    return *this;
  }
 
 
  inline const S3HudiSource& GetS3HudiSource() const { return m_s3HudiSource; }
  inline bool S3HudiSourceHasBeenSet() const { return m_s3HudiSourceHasBeenSet; }
  template <typename S3HudiSourceT = S3HudiSource>
  void SetS3HudiSource(S3HudiSourceT&& value) {
    m_s3HudiSourceHasBeenSet = true;
    m_s3HudiSource = std::forward<S3HudiSourceT>(value);
  }
  template <typename S3HudiSourceT = S3HudiSource>
  CodeGenConfigurationNode& WithS3HudiSource(S3HudiSourceT&& value) {
    SetS3HudiSource(std::forward<S3HudiSourceT>(value));
    return *this;
  }
 
 
  inline const S3HudiCatalogTarget& GetS3HudiCatalogTarget() const { return m_s3HudiCatalogTarget; }
  inline bool S3HudiCatalogTargetHasBeenSet() const { return m_s3HudiCatalogTargetHasBeenSet; }
  template <typename S3HudiCatalogTargetT = S3HudiCatalogTarget>
  void SetS3HudiCatalogTarget(S3HudiCatalogTargetT&& value) {
    m_s3HudiCatalogTargetHasBeenSet = true;
    m_s3HudiCatalogTarget = std::forward<S3HudiCatalogTargetT>(value);
  }
  template <typename S3HudiCatalogTargetT = S3HudiCatalogTarget>
  CodeGenConfigurationNode& WithS3HudiCatalogTarget(S3HudiCatalogTargetT&& value) {
    SetS3HudiCatalogTarget(std::forward<S3HudiCatalogTargetT>(value));
    return *this;
  }
 
 
  inline const S3HudiDirectTarget& GetS3HudiDirectTarget() const { return m_s3HudiDirectTarget; }
  inline bool S3HudiDirectTargetHasBeenSet() const { return m_s3HudiDirectTargetHasBeenSet; }
  template <typename S3HudiDirectTargetT = S3HudiDirectTarget>
  void SetS3HudiDirectTarget(S3HudiDirectTargetT&& value) {
    m_s3HudiDirectTargetHasBeenSet = true;
    m_s3HudiDirectTarget = std::forward<S3HudiDirectTargetT>(value);
  }
  template <typename S3HudiDirectTargetT = S3HudiDirectTarget>
  CodeGenConfigurationNode& WithS3HudiDirectTarget(S3HudiDirectTargetT&& value) {
    SetS3HudiDirectTarget(std::forward<S3HudiDirectTargetT>(value));
    return *this;
  }
 
 
  inline const DirectJDBCSource& GetDirectJDBCSource() const { return m_directJDBCSource; }
  inline bool DirectJDBCSourceHasBeenSet() const { return m_directJDBCSourceHasBeenSet; }
  template <typename DirectJDBCSourceT = DirectJDBCSource>
  void SetDirectJDBCSource(DirectJDBCSourceT&& value) {
    m_directJDBCSourceHasBeenSet = true;
    m_directJDBCSource = std::forward<DirectJDBCSourceT>(value);
  }
  template <typename DirectJDBCSourceT = DirectJDBCSource>
  CodeGenConfigurationNode& WithDirectJDBCSource(DirectJDBCSourceT&& value) {
    SetDirectJDBCSource(std::forward<DirectJDBCSourceT>(value));
    return *this;
  }
 
 
  inline const S3CatalogDeltaSource& GetS3CatalogDeltaSource() const { return m_s3CatalogDeltaSource; }
  inline bool S3CatalogDeltaSourceHasBeenSet() const { return m_s3CatalogDeltaSourceHasBeenSet; }
  template <typename S3CatalogDeltaSourceT = S3CatalogDeltaSource>
  void SetS3CatalogDeltaSource(S3CatalogDeltaSourceT&& value) {
    m_s3CatalogDeltaSourceHasBeenSet = true;
    m_s3CatalogDeltaSource = std::forward<S3CatalogDeltaSourceT>(value);
  }
  template <typename S3CatalogDeltaSourceT = S3CatalogDeltaSource>
  CodeGenConfigurationNode& WithS3CatalogDeltaSource(S3CatalogDeltaSourceT&& value) {
    SetS3CatalogDeltaSource(std::forward<S3CatalogDeltaSourceT>(value));
    return *this;
  }
 
 
  inline const CatalogDeltaSource& GetCatalogDeltaSource() const { return m_catalogDeltaSource; }
  inline bool CatalogDeltaSourceHasBeenSet() const { return m_catalogDeltaSourceHasBeenSet; }
  template <typename CatalogDeltaSourceT = CatalogDeltaSource>
  void SetCatalogDeltaSource(CatalogDeltaSourceT&& value) {
    m_catalogDeltaSourceHasBeenSet = true;
    m_catalogDeltaSource = std::forward<CatalogDeltaSourceT>(value);
  }
  template <typename CatalogDeltaSourceT = CatalogDeltaSource>
  CodeGenConfigurationNode& WithCatalogDeltaSource(CatalogDeltaSourceT&& value) {
    SetCatalogDeltaSource(std::forward<CatalogDeltaSourceT>(value));
    return *this;
  }
 
 
  inline const S3DeltaSource& GetS3DeltaSource() const { return m_s3DeltaSource; }
  inline bool S3DeltaSourceHasBeenSet() const { return m_s3DeltaSourceHasBeenSet; }
  template <typename S3DeltaSourceT = S3DeltaSource>
  void SetS3DeltaSource(S3DeltaSourceT&& value) {
    m_s3DeltaSourceHasBeenSet = true;
    m_s3DeltaSource = std::forward<S3DeltaSourceT>(value);
  }
  template <typename S3DeltaSourceT = S3DeltaSource>
  CodeGenConfigurationNode& WithS3DeltaSource(S3DeltaSourceT&& value) {
    SetS3DeltaSource(std::forward<S3DeltaSourceT>(value));
    return *this;
  }
 
 
  inline const S3DeltaCatalogTarget& GetS3DeltaCatalogTarget() const { return m_s3DeltaCatalogTarget; }
  inline bool S3DeltaCatalogTargetHasBeenSet() const { return m_s3DeltaCatalogTargetHasBeenSet; }
  template <typename S3DeltaCatalogTargetT = S3DeltaCatalogTarget>
  void SetS3DeltaCatalogTarget(S3DeltaCatalogTargetT&& value) {
    m_s3DeltaCatalogTargetHasBeenSet = true;
    m_s3DeltaCatalogTarget = std::forward<S3DeltaCatalogTargetT>(value);
  }
  template <typename S3DeltaCatalogTargetT = S3DeltaCatalogTarget>
  CodeGenConfigurationNode& WithS3DeltaCatalogTarget(S3DeltaCatalogTargetT&& value) {
    SetS3DeltaCatalogTarget(std::forward<S3DeltaCatalogTargetT>(value));
    return *this;
  }
 
 
  inline const S3DeltaDirectTarget& GetS3DeltaDirectTarget() const { return m_s3DeltaDirectTarget; }
  inline bool S3DeltaDirectTargetHasBeenSet() const { return m_s3DeltaDirectTargetHasBeenSet; }
  template <typename S3DeltaDirectTargetT = S3DeltaDirectTarget>
  void SetS3DeltaDirectTarget(S3DeltaDirectTargetT&& value) {
    m_s3DeltaDirectTargetHasBeenSet = true;
    m_s3DeltaDirectTarget = std::forward<S3DeltaDirectTargetT>(value);
  }
  template <typename S3DeltaDirectTargetT = S3DeltaDirectTarget>
  CodeGenConfigurationNode& WithS3DeltaDirectTarget(S3DeltaDirectTargetT&& value) {
    SetS3DeltaDirectTarget(std::forward<S3DeltaDirectTargetT>(value));
    return *this;
  }
 
 
  inline const AmazonRedshiftSource& GetAmazonRedshiftSource() const { return m_amazonRedshiftSource; }
  inline bool AmazonRedshiftSourceHasBeenSet() const { return m_amazonRedshiftSourceHasBeenSet; }
  template <typename AmazonRedshiftSourceT = AmazonRedshiftSource>
  void SetAmazonRedshiftSource(AmazonRedshiftSourceT&& value) {
    m_amazonRedshiftSourceHasBeenSet = true;
    m_amazonRedshiftSource = std::forward<AmazonRedshiftSourceT>(value);
  }
  template <typename AmazonRedshiftSourceT = AmazonRedshiftSource>
  CodeGenConfigurationNode& WithAmazonRedshiftSource(AmazonRedshiftSourceT&& value) {
    SetAmazonRedshiftSource(std::forward<AmazonRedshiftSourceT>(value));
    return *this;
  }
 
 
  inline const AmazonRedshiftTarget& GetAmazonRedshiftTarget() const { return m_amazonRedshiftTarget; }
  inline bool AmazonRedshiftTargetHasBeenSet() const { return m_amazonRedshiftTargetHasBeenSet; }
  template <typename AmazonRedshiftTargetT = AmazonRedshiftTarget>
  void SetAmazonRedshiftTarget(AmazonRedshiftTargetT&& value) {
    m_amazonRedshiftTargetHasBeenSet = true;
    m_amazonRedshiftTarget = std::forward<AmazonRedshiftTargetT>(value);
  }
  template <typename AmazonRedshiftTargetT = AmazonRedshiftTarget>
  CodeGenConfigurationNode& WithAmazonRedshiftTarget(AmazonRedshiftTargetT&& value) {
    SetAmazonRedshiftTarget(std::forward<AmazonRedshiftTargetT>(value));
    return *this;
  }
 
 
  inline const EvaluateDataQualityMultiFrame& GetEvaluateDataQualityMultiFrame() const { return m_evaluateDataQualityMultiFrame; }
  inline bool EvaluateDataQualityMultiFrameHasBeenSet() const { return m_evaluateDataQualityMultiFrameHasBeenSet; }
  template <typename EvaluateDataQualityMultiFrameT = EvaluateDataQualityMultiFrame>
  void SetEvaluateDataQualityMultiFrame(EvaluateDataQualityMultiFrameT&& value) {
    m_evaluateDataQualityMultiFrameHasBeenSet = true;
    m_evaluateDataQualityMultiFrame = std::forward<EvaluateDataQualityMultiFrameT>(value);
  }
  template <typename EvaluateDataQualityMultiFrameT = EvaluateDataQualityMultiFrame>
  CodeGenConfigurationNode& WithEvaluateDataQualityMultiFrame(EvaluateDataQualityMultiFrameT&& value) {
    SetEvaluateDataQualityMultiFrame(std::forward<EvaluateDataQualityMultiFrameT>(value));
    return *this;
  }
 
 
  inline const Recipe& GetRecipe() const { return m_recipe; }
  inline bool RecipeHasBeenSet() const { return m_recipeHasBeenSet; }
  template <typename RecipeT = Recipe>
  void SetRecipe(RecipeT&& value) {
    m_recipeHasBeenSet = true;
    m_recipe = std::forward<RecipeT>(value);
  }
  template <typename RecipeT = Recipe>
  CodeGenConfigurationNode& WithRecipe(RecipeT&& value) {
    SetRecipe(std::forward<RecipeT>(value));
    return *this;
  }
 
 
  inline const SnowflakeSource& GetSnowflakeSource() const { return m_snowflakeSource; }
  inline bool SnowflakeSourceHasBeenSet() const { return m_snowflakeSourceHasBeenSet; }
  template <typename SnowflakeSourceT = SnowflakeSource>
  void SetSnowflakeSource(SnowflakeSourceT&& value) {
    m_snowflakeSourceHasBeenSet = true;
    m_snowflakeSource = std::forward<SnowflakeSourceT>(value);
  }
  template <typename SnowflakeSourceT = SnowflakeSource>
  CodeGenConfigurationNode& WithSnowflakeSource(SnowflakeSourceT&& value) {
    SetSnowflakeSource(std::forward<SnowflakeSourceT>(value));
    return *this;
  }
 
 
  inline const SnowflakeTarget& GetSnowflakeTarget() const { return m_snowflakeTarget; }
  inline bool SnowflakeTargetHasBeenSet() const { return m_snowflakeTargetHasBeenSet; }
  template <typename SnowflakeTargetT = SnowflakeTarget>
  void SetSnowflakeTarget(SnowflakeTargetT&& value) {
    m_snowflakeTargetHasBeenSet = true;
    m_snowflakeTarget = std::forward<SnowflakeTargetT>(value);
  }
  template <typename SnowflakeTargetT = SnowflakeTarget>
  CodeGenConfigurationNode& WithSnowflakeTarget(SnowflakeTargetT&& value) {
    SetSnowflakeTarget(std::forward<SnowflakeTargetT>(value));
    return *this;
  }
 
 
  inline const ConnectorDataSource& GetConnectorDataSource() const { return m_connectorDataSource; }
  inline bool ConnectorDataSourceHasBeenSet() const { return m_connectorDataSourceHasBeenSet; }
  template <typename ConnectorDataSourceT = ConnectorDataSource>
  void SetConnectorDataSource(ConnectorDataSourceT&& value) {
    m_connectorDataSourceHasBeenSet = true;
    m_connectorDataSource = std::forward<ConnectorDataSourceT>(value);
  }
  template <typename ConnectorDataSourceT = ConnectorDataSource>
  CodeGenConfigurationNode& WithConnectorDataSource(ConnectorDataSourceT&& value) {
    SetConnectorDataSource(std::forward<ConnectorDataSourceT>(value));
    return *this;
  }
 
 
  inline const ConnectorDataTarget& GetConnectorDataTarget() const { return m_connectorDataTarget; }
  inline bool ConnectorDataTargetHasBeenSet() const { return m_connectorDataTargetHasBeenSet; }
  template <typename ConnectorDataTargetT = ConnectorDataTarget>
  void SetConnectorDataTarget(ConnectorDataTargetT&& value) {
    m_connectorDataTargetHasBeenSet = true;
    m_connectorDataTarget = std::forward<ConnectorDataTargetT>(value);
  }
  template <typename ConnectorDataTargetT = ConnectorDataTarget>
  CodeGenConfigurationNode& WithConnectorDataTarget(ConnectorDataTargetT&& value) {
    SetConnectorDataTarget(std::forward<ConnectorDataTargetT>(value));
    return *this;
  }
 
 
  inline const S3CatalogIcebergSource& GetS3CatalogIcebergSource() const { return m_s3CatalogIcebergSource; }
  inline bool S3CatalogIcebergSourceHasBeenSet() const { return m_s3CatalogIcebergSourceHasBeenSet; }
  template <typename S3CatalogIcebergSourceT = S3CatalogIcebergSource>
  void SetS3CatalogIcebergSource(S3CatalogIcebergSourceT&& value) {
    m_s3CatalogIcebergSourceHasBeenSet = true;
    m_s3CatalogIcebergSource = std::forward<S3CatalogIcebergSourceT>(value);
  }
  template <typename S3CatalogIcebergSourceT = S3CatalogIcebergSource>
  CodeGenConfigurationNode& WithS3CatalogIcebergSource(S3CatalogIcebergSourceT&& value) {
    SetS3CatalogIcebergSource(std::forward<S3CatalogIcebergSourceT>(value));
    return *this;
  }
 
 
  inline const CatalogIcebergSource& GetCatalogIcebergSource() const { return m_catalogIcebergSource; }
  inline bool CatalogIcebergSourceHasBeenSet() const { return m_catalogIcebergSourceHasBeenSet; }
  template <typename CatalogIcebergSourceT = CatalogIcebergSource>
  void SetCatalogIcebergSource(CatalogIcebergSourceT&& value) {
    m_catalogIcebergSourceHasBeenSet = true;
    m_catalogIcebergSource = std::forward<CatalogIcebergSourceT>(value);
  }
  template <typename CatalogIcebergSourceT = CatalogIcebergSource>
  CodeGenConfigurationNode& WithCatalogIcebergSource(CatalogIcebergSourceT&& value) {
    SetCatalogIcebergSource(std::forward<CatalogIcebergSourceT>(value));
    return *this;
  }
 
 
  inline const S3IcebergCatalogTarget& GetS3IcebergCatalogTarget() const { return m_s3IcebergCatalogTarget; }
  inline bool S3IcebergCatalogTargetHasBeenSet() const { return m_s3IcebergCatalogTargetHasBeenSet; }
  template <typename S3IcebergCatalogTargetT = S3IcebergCatalogTarget>
  void SetS3IcebergCatalogTarget(S3IcebergCatalogTargetT&& value) {
    m_s3IcebergCatalogTargetHasBeenSet = true;
    m_s3IcebergCatalogTarget = std::forward<S3IcebergCatalogTargetT>(value);
  }
  template <typename S3IcebergCatalogTargetT = S3IcebergCatalogTarget>
  CodeGenConfigurationNode& WithS3IcebergCatalogTarget(S3IcebergCatalogTargetT&& value) {
    SetS3IcebergCatalogTarget(std::forward<S3IcebergCatalogTargetT>(value));
    return *this;
  }
 
 
  inline const S3IcebergDirectTarget& GetS3IcebergDirectTarget() const { return m_s3IcebergDirectTarget; }
  inline bool S3IcebergDirectTargetHasBeenSet() const { return m_s3IcebergDirectTargetHasBeenSet; }
  template <typename S3IcebergDirectTargetT = S3IcebergDirectTarget>
  void SetS3IcebergDirectTarget(S3IcebergDirectTargetT&& value) {
    m_s3IcebergDirectTargetHasBeenSet = true;
    m_s3IcebergDirectTarget = std::forward<S3IcebergDirectTargetT>(value);
  }
  template <typename S3IcebergDirectTargetT = S3IcebergDirectTarget>
  CodeGenConfigurationNode& WithS3IcebergDirectTarget(S3IcebergDirectTargetT&& value) {
    SetS3IcebergDirectTarget(std::forward<S3IcebergDirectTargetT>(value));
    return *this;
  }
 
 
  inline const S3ExcelSource& GetS3ExcelSource() const { return m_s3ExcelSource; }
  inline bool S3ExcelSourceHasBeenSet() const { return m_s3ExcelSourceHasBeenSet; }
  template <typename S3ExcelSourceT = S3ExcelSource>
  void SetS3ExcelSource(S3ExcelSourceT&& value) {
    m_s3ExcelSourceHasBeenSet = true;
    m_s3ExcelSource = std::forward<S3ExcelSourceT>(value);
  }
  template <typename S3ExcelSourceT = S3ExcelSource>
  CodeGenConfigurationNode& WithS3ExcelSource(S3ExcelSourceT&& value) {
    SetS3ExcelSource(std::forward<S3ExcelSourceT>(value));
    return *this;
  }
 
 
  inline const S3HyperDirectTarget& GetS3HyperDirectTarget() const { return m_s3HyperDirectTarget; }
  inline bool S3HyperDirectTargetHasBeenSet() const { return m_s3HyperDirectTargetHasBeenSet; }
  template <typename S3HyperDirectTargetT = S3HyperDirectTarget>
  void SetS3HyperDirectTarget(S3HyperDirectTargetT&& value) {
    m_s3HyperDirectTargetHasBeenSet = true;
    m_s3HyperDirectTarget = std::forward<S3HyperDirectTargetT>(value);
  }
  template <typename S3HyperDirectTargetT = S3HyperDirectTarget>
  CodeGenConfigurationNode& WithS3HyperDirectTarget(S3HyperDirectTargetT&& value) {
    SetS3HyperDirectTarget(std::forward<S3HyperDirectTargetT>(value));
    return *this;
  }
 
 
  inline const DynamoDBELTConnectorSource& GetDynamoDBELTConnectorSource() const { return m_dynamoDBELTConnectorSource; }
  inline bool DynamoDBELTConnectorSourceHasBeenSet() const { return m_dynamoDBELTConnectorSourceHasBeenSet; }
  template <typename DynamoDBELTConnectorSourceT = DynamoDBELTConnectorSource>
  void SetDynamoDBELTConnectorSource(DynamoDBELTConnectorSourceT&& value) {
    m_dynamoDBELTConnectorSourceHasBeenSet = true;
    m_dynamoDBELTConnectorSource = std::forward<DynamoDBELTConnectorSourceT>(value);
  }
  template <typename DynamoDBELTConnectorSourceT = DynamoDBELTConnectorSource>
  CodeGenConfigurationNode& WithDynamoDBELTConnectorSource(DynamoDBELTConnectorSourceT&& value) {
    SetDynamoDBELTConnectorSource(std::forward<DynamoDBELTConnectorSourceT>(value));
    return *this;
  }
 private:
  AthenaConnectorSource m_athenaConnectorSource;
 
  JDBCConnectorSource m_jDBCConnectorSource;
 
  SparkConnectorSource m_sparkConnectorSource;
 
  CatalogSource m_catalogSource;
 
  RedshiftSource m_redshiftSource;
 
  S3CatalogSource m_s3CatalogSource;
 
  S3CsvSource m_s3CsvSource;
 
  S3JsonSource m_s3JsonSource;
 
  S3ParquetSource m_s3ParquetSource;
 
  RelationalCatalogSource m_relationalCatalogSource;
 
  DynamoDBCatalogSource m_dynamoDBCatalogSource;
 
  JDBCConnectorTarget m_jDBCConnectorTarget;
 
  SparkConnectorTarget m_sparkConnectorTarget;
 
  BasicCatalogTarget m_catalogTarget;
 
  RedshiftTarget m_redshiftTarget;
 
  S3CatalogTarget m_s3CatalogTarget;
 
  S3GlueParquetTarget m_s3GlueParquetTarget;
 
  S3DirectTarget m_s3DirectTarget;
 
  ApplyMapping m_applyMapping;
 
  SelectFields m_selectFields;
 
  DropFields m_dropFields;
 
  RenameField m_renameField;
 
  Spigot m_spigot;
 
  Join m_join;
 
  SplitFields m_splitFields;
 
  SelectFromCollection m_selectFromCollection;
 
  FillMissingValues m_fillMissingValues;
 
  Filter m_filter;
 
  CustomCode m_customCode;
 
  SparkSQL m_sparkSQL;
 
  DirectKinesisSource m_directKinesisSource;
 
  DirectKafkaSource m_directKafkaSource;
 
  CatalogKinesisSource m_catalogKinesisSource;
 
  CatalogKafkaSource m_catalogKafkaSource;
 
  DropNullFields m_dropNullFields;
 
  Merge m_merge;
 
  Union m_union;
 
  PIIDetection m_pIIDetection;
 
  Aggregate m_aggregate;
 
  DropDuplicates m_dropDuplicates;
 
  GovernedCatalogTarget m_governedCatalogTarget;
 
  GovernedCatalogSource m_governedCatalogSource;
 
  MicrosoftSQLServerCatalogSource m_microsoftSQLServerCatalogSource;
 
  MySQLCatalogSource m_mySQLCatalogSource;
 
  OracleSQLCatalogSource m_oracleSQLCatalogSource;
 
  PostgreSQLCatalogSource m_postgreSQLCatalogSource;
 
  MicrosoftSQLServerCatalogTarget m_microsoftSQLServerCatalogTarget;
 
  MySQLCatalogTarget m_mySQLCatalogTarget;
 
  OracleSQLCatalogTarget m_oracleSQLCatalogTarget;
 
  PostgreSQLCatalogTarget m_postgreSQLCatalogTarget;
 
  Route m_route;
 
  DynamicTransform m_dynamicTransform;
 
  EvaluateDataQuality m_evaluateDataQuality;
 
  S3CatalogHudiSource m_s3CatalogHudiSource;
 
  CatalogHudiSource m_catalogHudiSource;
 
  S3HudiSource m_s3HudiSource;
 
  S3HudiCatalogTarget m_s3HudiCatalogTarget;
 
  S3HudiDirectTarget m_s3HudiDirectTarget;
 
  DirectJDBCSource m_directJDBCSource;
 
  S3CatalogDeltaSource m_s3CatalogDeltaSource;
 
  CatalogDeltaSource m_catalogDeltaSource;
 
  S3DeltaSource m_s3DeltaSource;
 
  S3DeltaCatalogTarget m_s3DeltaCatalogTarget;
 
  S3DeltaDirectTarget m_s3DeltaDirectTarget;
 
  AmazonRedshiftSource m_amazonRedshiftSource;
 
  AmazonRedshiftTarget m_amazonRedshiftTarget;
 
  EvaluateDataQualityMultiFrame m_evaluateDataQualityMultiFrame;
 
  Recipe m_recipe;
 
  SnowflakeSource m_snowflakeSource;
 
  SnowflakeTarget m_snowflakeTarget;
 
  ConnectorDataSource m_connectorDataSource;
 
  ConnectorDataTarget m_connectorDataTarget;
 
  S3CatalogIcebergSource m_s3CatalogIcebergSource;
 
  CatalogIcebergSource m_catalogIcebergSource;
 
  S3IcebergCatalogTarget m_s3IcebergCatalogTarget;
 
  S3IcebergDirectTarget m_s3IcebergDirectTarget;
 
  S3ExcelSource m_s3ExcelSource;
 
  S3HyperDirectTarget m_s3HyperDirectTarget;
 
  DynamoDBELTConnectorSource m_dynamoDBELTConnectorSource;
  bool m_athenaConnectorSourceHasBeenSet = false;
  bool m_jDBCConnectorSourceHasBeenSet = false;
  bool m_sparkConnectorSourceHasBeenSet = false;
  bool m_catalogSourceHasBeenSet = false;
  bool m_redshiftSourceHasBeenSet = false;
  bool m_s3CatalogSourceHasBeenSet = false;
  bool m_s3CsvSourceHasBeenSet = false;
  bool m_s3JsonSourceHasBeenSet = false;
  bool m_s3ParquetSourceHasBeenSet = false;
  bool m_relationalCatalogSourceHasBeenSet = false;
  bool m_dynamoDBCatalogSourceHasBeenSet = false;
  bool m_jDBCConnectorTargetHasBeenSet = false;
  bool m_sparkConnectorTargetHasBeenSet = false;
  bool m_catalogTargetHasBeenSet = false;
  bool m_redshiftTargetHasBeenSet = false;
  bool m_s3CatalogTargetHasBeenSet = false;
  bool m_s3GlueParquetTargetHasBeenSet = false;
  bool m_s3DirectTargetHasBeenSet = false;
  bool m_applyMappingHasBeenSet = false;
  bool m_selectFieldsHasBeenSet = false;
  bool m_dropFieldsHasBeenSet = false;
  bool m_renameFieldHasBeenSet = false;
  bool m_spigotHasBeenSet = false;
  bool m_joinHasBeenSet = false;
  bool m_splitFieldsHasBeenSet = false;
  bool m_selectFromCollectionHasBeenSet = false;
  bool m_fillMissingValuesHasBeenSet = false;
  bool m_filterHasBeenSet = false;
  bool m_customCodeHasBeenSet = false;
  bool m_sparkSQLHasBeenSet = false;
  bool m_directKinesisSourceHasBeenSet = false;
  bool m_directKafkaSourceHasBeenSet = false;
  bool m_catalogKinesisSourceHasBeenSet = false;
  bool m_catalogKafkaSourceHasBeenSet = false;
  bool m_dropNullFieldsHasBeenSet = false;
  bool m_mergeHasBeenSet = false;
  bool m_unionHasBeenSet = false;
  bool m_pIIDetectionHasBeenSet = false;
  bool m_aggregateHasBeenSet = false;
  bool m_dropDuplicatesHasBeenSet = false;
  bool m_governedCatalogTargetHasBeenSet = false;
  bool m_governedCatalogSourceHasBeenSet = false;
  bool m_microsoftSQLServerCatalogSourceHasBeenSet = false;
  bool m_mySQLCatalogSourceHasBeenSet = false;
  bool m_oracleSQLCatalogSourceHasBeenSet = false;
  bool m_postgreSQLCatalogSourceHasBeenSet = false;
  bool m_microsoftSQLServerCatalogTargetHasBeenSet = false;
  bool m_mySQLCatalogTargetHasBeenSet = false;
  bool m_oracleSQLCatalogTargetHasBeenSet = false;
  bool m_postgreSQLCatalogTargetHasBeenSet = false;
  bool m_routeHasBeenSet = false;
  bool m_dynamicTransformHasBeenSet = false;
  bool m_evaluateDataQualityHasBeenSet = false;
  bool m_s3CatalogHudiSourceHasBeenSet = false;
  bool m_catalogHudiSourceHasBeenSet = false;
  bool m_s3HudiSourceHasBeenSet = false;
  bool m_s3HudiCatalogTargetHasBeenSet = false;
  bool m_s3HudiDirectTargetHasBeenSet = false;
  bool m_directJDBCSourceHasBeenSet = false;
  bool m_s3CatalogDeltaSourceHasBeenSet = false;
  bool m_catalogDeltaSourceHasBeenSet = false;
  bool m_s3DeltaSourceHasBeenSet = false;
  bool m_s3DeltaCatalogTargetHasBeenSet = false;
  bool m_s3DeltaDirectTargetHasBeenSet = false;
  bool m_amazonRedshiftSourceHasBeenSet = false;
  bool m_amazonRedshiftTargetHasBeenSet = false;
  bool m_evaluateDataQualityMultiFrameHasBeenSet = false;
  bool m_recipeHasBeenSet = false;
  bool m_snowflakeSourceHasBeenSet = false;
  bool m_snowflakeTargetHasBeenSet = false;
  bool m_connectorDataSourceHasBeenSet = false;
  bool m_connectorDataTargetHasBeenSet = false;
  bool m_s3CatalogIcebergSourceHasBeenSet = false;
  bool m_catalogIcebergSourceHasBeenSet = false;
  bool m_s3IcebergCatalogTargetHasBeenSet = false;
  bool m_s3IcebergDirectTargetHasBeenSet = false;
  bool m_s3ExcelSourceHasBeenSet = false;
  bool m_s3HyperDirectTargetHasBeenSet = false;
  bool m_dynamoDBELTConnectorSourceHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Glue
}  // namespace Aws