RunJobFlowRequest.h

 
#pragma once
#include <aws/elasticmapreduce/EMR_EXPORTS.h>
#include <aws/elasticmapreduce/EMRRequest.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/elasticmapreduce/model/JobFlowInstancesConfig.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/elasticmapreduce/model/ScaleDownBehavior.h>
#include <aws/elasticmapreduce/model/RepoUpgradeOnBoot.h>
#include <aws/elasticmapreduce/model/KerberosAttributes.h>
#include <aws/elasticmapreduce/model/ManagedScalingPolicy.h>
#include <aws/elasticmapreduce/model/AutoTerminationPolicy.h>
#include <aws/elasticmapreduce/model/StepConfig.h>
#include <aws/elasticmapreduce/model/BootstrapActionConfig.h>
#include <aws/elasticmapreduce/model/SupportedProductConfig.h>
#include <aws/elasticmapreduce/model/Application.h>
#include <aws/elasticmapreduce/model/Configuration.h>
#include <aws/elasticmapreduce/model/Tag.h>
#include <aws/elasticmapreduce/model/PlacementGroupConfig.h>
#include <utility>
 
namespace Aws
{
namespace EMR
{
namespace Model
{
 
  class RunJobFlowRequest : public EMRRequest
  {
  public:
    AWS_EMR_API RunJobFlowRequest() = 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 "RunJobFlow"; }
 
    AWS_EMR_API Aws::String SerializePayload() const override;
 
    AWS_EMR_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
 
 
 
    inline const Aws::String& GetName() const { return m_name; }
    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
    template<typename NameT = Aws::String>
    void SetName(NameT&& value) { m_nameHasBeenSet = true; m_name = std::forward<NameT>(value); }
    template<typename NameT = Aws::String>
    RunJobFlowRequest& WithName(NameT&& value) { SetName(std::forward<NameT>(value)); return *this;}
 
 
    inline const Aws::String& GetLogUri() const { return m_logUri; }
    inline bool LogUriHasBeenSet() const { return m_logUriHasBeenSet; }
    template<typename LogUriT = Aws::String>
    void SetLogUri(LogUriT&& value) { m_logUriHasBeenSet = true; m_logUri = std::forward<LogUriT>(value); }
    template<typename LogUriT = Aws::String>
    RunJobFlowRequest& WithLogUri(LogUriT&& value) { SetLogUri(std::forward<LogUriT>(value)); return *this;}
 
 
    inline const Aws::String& GetLogEncryptionKmsKeyId() const { return m_logEncryptionKmsKeyId; }
    inline bool LogEncryptionKmsKeyIdHasBeenSet() const { return m_logEncryptionKmsKeyIdHasBeenSet; }
    template<typename LogEncryptionKmsKeyIdT = Aws::String>
    void SetLogEncryptionKmsKeyId(LogEncryptionKmsKeyIdT&& value) { m_logEncryptionKmsKeyIdHasBeenSet = true; m_logEncryptionKmsKeyId = std::forward<LogEncryptionKmsKeyIdT>(value); }
    template<typename LogEncryptionKmsKeyIdT = Aws::String>
    RunJobFlowRequest& WithLogEncryptionKmsKeyId(LogEncryptionKmsKeyIdT&& value) { SetLogEncryptionKmsKeyId(std::forward<LogEncryptionKmsKeyIdT>(value)); return *this;}
 
 
    inline const Aws::String& GetAdditionalInfo() const { return m_additionalInfo; }
    inline bool AdditionalInfoHasBeenSet() const { return m_additionalInfoHasBeenSet; }
    template<typename AdditionalInfoT = Aws::String>
    void SetAdditionalInfo(AdditionalInfoT&& value) { m_additionalInfoHasBeenSet = true; m_additionalInfo = std::forward<AdditionalInfoT>(value); }
    template<typename AdditionalInfoT = Aws::String>
    RunJobFlowRequest& WithAdditionalInfo(AdditionalInfoT&& value) { SetAdditionalInfo(std::forward<AdditionalInfoT>(value)); return *this;}
 
 
    inline const Aws::String& GetAmiVersion() const { return m_amiVersion; }
    inline bool AmiVersionHasBeenSet() const { return m_amiVersionHasBeenSet; }
    template<typename AmiVersionT = Aws::String>
    void SetAmiVersion(AmiVersionT&& value) { m_amiVersionHasBeenSet = true; m_amiVersion = std::forward<AmiVersionT>(value); }
    template<typename AmiVersionT = Aws::String>
    RunJobFlowRequest& WithAmiVersion(AmiVersionT&& value) { SetAmiVersion(std::forward<AmiVersionT>(value)); return *this;}
 
 
    inline const Aws::String& GetReleaseLabel() const { return m_releaseLabel; }
    inline bool ReleaseLabelHasBeenSet() const { return m_releaseLabelHasBeenSet; }
    template<typename ReleaseLabelT = Aws::String>
    void SetReleaseLabel(ReleaseLabelT&& value) { m_releaseLabelHasBeenSet = true; m_releaseLabel = std::forward<ReleaseLabelT>(value); }
    template<typename ReleaseLabelT = Aws::String>
    RunJobFlowRequest& WithReleaseLabel(ReleaseLabelT&& value) { SetReleaseLabel(std::forward<ReleaseLabelT>(value)); return *this;}
 
 
    inline const JobFlowInstancesConfig& GetInstances() const { return m_instances; }
    inline bool InstancesHasBeenSet() const { return m_instancesHasBeenSet; }
    template<typename InstancesT = JobFlowInstancesConfig>
    void SetInstances(InstancesT&& value) { m_instancesHasBeenSet = true; m_instances = std::forward<InstancesT>(value); }
    template<typename InstancesT = JobFlowInstancesConfig>
    RunJobFlowRequest& WithInstances(InstancesT&& value) { SetInstances(std::forward<InstancesT>(value)); return *this;}
 
 
    inline const Aws::Vector<StepConfig>& GetSteps() const { return m_steps; }
    inline bool StepsHasBeenSet() const { return m_stepsHasBeenSet; }
    template<typename StepsT = Aws::Vector<StepConfig>>
    void SetSteps(StepsT&& value) { m_stepsHasBeenSet = true; m_steps = std::forward<StepsT>(value); }
    template<typename StepsT = Aws::Vector<StepConfig>>
    RunJobFlowRequest& WithSteps(StepsT&& value) { SetSteps(std::forward<StepsT>(value)); return *this;}
    template<typename StepsT = StepConfig>
    RunJobFlowRequest& AddSteps(StepsT&& value) { m_stepsHasBeenSet = true; m_steps.emplace_back(std::forward<StepsT>(value)); return *this; }
 
 
    inline const Aws::Vector<BootstrapActionConfig>& GetBootstrapActions() const { return m_bootstrapActions; }
    inline bool BootstrapActionsHasBeenSet() const { return m_bootstrapActionsHasBeenSet; }
    template<typename BootstrapActionsT = Aws::Vector<BootstrapActionConfig>>
    void SetBootstrapActions(BootstrapActionsT&& value) { m_bootstrapActionsHasBeenSet = true; m_bootstrapActions = std::forward<BootstrapActionsT>(value); }
    template<typename BootstrapActionsT = Aws::Vector<BootstrapActionConfig>>
    RunJobFlowRequest& WithBootstrapActions(BootstrapActionsT&& value) { SetBootstrapActions(std::forward<BootstrapActionsT>(value)); return *this;}
    template<typename BootstrapActionsT = BootstrapActionConfig>
    RunJobFlowRequest& AddBootstrapActions(BootstrapActionsT&& value) { m_bootstrapActionsHasBeenSet = true; m_bootstrapActions.emplace_back(std::forward<BootstrapActionsT>(value)); return *this; }
 
 
    inline const Aws::Vector<Aws::String>& GetSupportedProducts() const { return m_supportedProducts; }
    inline bool SupportedProductsHasBeenSet() const { return m_supportedProductsHasBeenSet; }
    template<typename SupportedProductsT = Aws::Vector<Aws::String>>
    void SetSupportedProducts(SupportedProductsT&& value) { m_supportedProductsHasBeenSet = true; m_supportedProducts = std::forward<SupportedProductsT>(value); }
    template<typename SupportedProductsT = Aws::Vector<Aws::String>>
    RunJobFlowRequest& WithSupportedProducts(SupportedProductsT&& value) { SetSupportedProducts(std::forward<SupportedProductsT>(value)); return *this;}
    template<typename SupportedProductsT = Aws::String>
    RunJobFlowRequest& AddSupportedProducts(SupportedProductsT&& value) { m_supportedProductsHasBeenSet = true; m_supportedProducts.emplace_back(std::forward<SupportedProductsT>(value)); return *this; }
 
 
    inline const Aws::Vector<SupportedProductConfig>& GetNewSupportedProducts() const { return m_newSupportedProducts; }
    inline bool NewSupportedProductsHasBeenSet() const { return m_newSupportedProductsHasBeenSet; }
    template<typename NewSupportedProductsT = Aws::Vector<SupportedProductConfig>>
    void SetNewSupportedProducts(NewSupportedProductsT&& value) { m_newSupportedProductsHasBeenSet = true; m_newSupportedProducts = std::forward<NewSupportedProductsT>(value); }
    template<typename NewSupportedProductsT = Aws::Vector<SupportedProductConfig>>
    RunJobFlowRequest& WithNewSupportedProducts(NewSupportedProductsT&& value) { SetNewSupportedProducts(std::forward<NewSupportedProductsT>(value)); return *this;}
    template<typename NewSupportedProductsT = SupportedProductConfig>
    RunJobFlowRequest& AddNewSupportedProducts(NewSupportedProductsT&& value) { m_newSupportedProductsHasBeenSet = true; m_newSupportedProducts.emplace_back(std::forward<NewSupportedProductsT>(value)); return *this; }
 
 
    inline const Aws::Vector<Application>& GetApplications() const { return m_applications; }
    inline bool ApplicationsHasBeenSet() const { return m_applicationsHasBeenSet; }
    template<typename ApplicationsT = Aws::Vector<Application>>
    void SetApplications(ApplicationsT&& value) { m_applicationsHasBeenSet = true; m_applications = std::forward<ApplicationsT>(value); }
    template<typename ApplicationsT = Aws::Vector<Application>>
    RunJobFlowRequest& WithApplications(ApplicationsT&& value) { SetApplications(std::forward<ApplicationsT>(value)); return *this;}
    template<typename ApplicationsT = Application>
    RunJobFlowRequest& AddApplications(ApplicationsT&& value) { m_applicationsHasBeenSet = true; m_applications.emplace_back(std::forward<ApplicationsT>(value)); return *this; }
 
 
    inline const Aws::Vector<Configuration>& GetConfigurations() const { return m_configurations; }
    inline bool ConfigurationsHasBeenSet() const { return m_configurationsHasBeenSet; }
    template<typename ConfigurationsT = Aws::Vector<Configuration>>
    void SetConfigurations(ConfigurationsT&& value) { m_configurationsHasBeenSet = true; m_configurations = std::forward<ConfigurationsT>(value); }
    template<typename ConfigurationsT = Aws::Vector<Configuration>>
    RunJobFlowRequest& WithConfigurations(ConfigurationsT&& value) { SetConfigurations(std::forward<ConfigurationsT>(value)); return *this;}
    template<typename ConfigurationsT = Configuration>
    RunJobFlowRequest& AddConfigurations(ConfigurationsT&& value) { m_configurationsHasBeenSet = true; m_configurations.emplace_back(std::forward<ConfigurationsT>(value)); return *this; }
 
 
    inline bool GetVisibleToAllUsers() const { return m_visibleToAllUsers; }
    inline bool VisibleToAllUsersHasBeenSet() const { return m_visibleToAllUsersHasBeenSet; }
    inline void SetVisibleToAllUsers(bool value) { m_visibleToAllUsersHasBeenSet = true; m_visibleToAllUsers = value; }
    inline RunJobFlowRequest& WithVisibleToAllUsers(bool value) { SetVisibleToAllUsers(value); return *this;}
 
 
    inline const Aws::String& GetJobFlowRole() const { return m_jobFlowRole; }
    inline bool JobFlowRoleHasBeenSet() const { return m_jobFlowRoleHasBeenSet; }
    template<typename JobFlowRoleT = Aws::String>
    void SetJobFlowRole(JobFlowRoleT&& value) { m_jobFlowRoleHasBeenSet = true; m_jobFlowRole = std::forward<JobFlowRoleT>(value); }
    template<typename JobFlowRoleT = Aws::String>
    RunJobFlowRequest& WithJobFlowRole(JobFlowRoleT&& value) { SetJobFlowRole(std::forward<JobFlowRoleT>(value)); return *this;}
 
 
    inline const Aws::String& GetServiceRole() const { return m_serviceRole; }
    inline bool ServiceRoleHasBeenSet() const { return m_serviceRoleHasBeenSet; }
    template<typename ServiceRoleT = Aws::String>
    void SetServiceRole(ServiceRoleT&& value) { m_serviceRoleHasBeenSet = true; m_serviceRole = std::forward<ServiceRoleT>(value); }
    template<typename ServiceRoleT = Aws::String>
    RunJobFlowRequest& WithServiceRole(ServiceRoleT&& value) { SetServiceRole(std::forward<ServiceRoleT>(value)); return *this;}
 
 
    inline const Aws::Vector<Tag>& GetTags() const { return m_tags; }
    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
    template<typename TagsT = Aws::Vector<Tag>>
    void SetTags(TagsT&& value) { m_tagsHasBeenSet = true; m_tags = std::forward<TagsT>(value); }
    template<typename TagsT = Aws::Vector<Tag>>
    RunJobFlowRequest& WithTags(TagsT&& value) { SetTags(std::forward<TagsT>(value)); return *this;}
    template<typename TagsT = Tag>
    RunJobFlowRequest& AddTags(TagsT&& value) { m_tagsHasBeenSet = true; m_tags.emplace_back(std::forward<TagsT>(value)); return *this; }
 
 
    inline const Aws::String& GetSecurityConfiguration() const { return m_securityConfiguration; }
    inline bool SecurityConfigurationHasBeenSet() const { return m_securityConfigurationHasBeenSet; }
    template<typename SecurityConfigurationT = Aws::String>
    void SetSecurityConfiguration(SecurityConfigurationT&& value) { m_securityConfigurationHasBeenSet = true; m_securityConfiguration = std::forward<SecurityConfigurationT>(value); }
    template<typename SecurityConfigurationT = Aws::String>
    RunJobFlowRequest& WithSecurityConfiguration(SecurityConfigurationT&& value) { SetSecurityConfiguration(std::forward<SecurityConfigurationT>(value)); return *this;}
 
 
    inline const Aws::String& GetAutoScalingRole() const { return m_autoScalingRole; }
    inline bool AutoScalingRoleHasBeenSet() const { return m_autoScalingRoleHasBeenSet; }
    template<typename AutoScalingRoleT = Aws::String>
    void SetAutoScalingRole(AutoScalingRoleT&& value) { m_autoScalingRoleHasBeenSet = true; m_autoScalingRole = std::forward<AutoScalingRoleT>(value); }
    template<typename AutoScalingRoleT = Aws::String>
    RunJobFlowRequest& WithAutoScalingRole(AutoScalingRoleT&& value) { SetAutoScalingRole(std::forward<AutoScalingRoleT>(value)); return *this;}
 
 
    inline ScaleDownBehavior GetScaleDownBehavior() const { return m_scaleDownBehavior; }
    inline bool ScaleDownBehaviorHasBeenSet() const { return m_scaleDownBehaviorHasBeenSet; }
    inline void SetScaleDownBehavior(ScaleDownBehavior value) { m_scaleDownBehaviorHasBeenSet = true; m_scaleDownBehavior = value; }
    inline RunJobFlowRequest& WithScaleDownBehavior(ScaleDownBehavior value) { SetScaleDownBehavior(value); return *this;}
 
 
    inline const Aws::String& GetCustomAmiId() const { return m_customAmiId; }
    inline bool CustomAmiIdHasBeenSet() const { return m_customAmiIdHasBeenSet; }
    template<typename CustomAmiIdT = Aws::String>
    void SetCustomAmiId(CustomAmiIdT&& value) { m_customAmiIdHasBeenSet = true; m_customAmiId = std::forward<CustomAmiIdT>(value); }
    template<typename CustomAmiIdT = Aws::String>
    RunJobFlowRequest& WithCustomAmiId(CustomAmiIdT&& value) { SetCustomAmiId(std::forward<CustomAmiIdT>(value)); return *this;}
 
 
    inline int GetEbsRootVolumeSize() const { return m_ebsRootVolumeSize; }
    inline bool EbsRootVolumeSizeHasBeenSet() const { return m_ebsRootVolumeSizeHasBeenSet; }
    inline void SetEbsRootVolumeSize(int value) { m_ebsRootVolumeSizeHasBeenSet = true; m_ebsRootVolumeSize = value; }
    inline RunJobFlowRequest& WithEbsRootVolumeSize(int value) { SetEbsRootVolumeSize(value); return *this;}
 
 
    inline RepoUpgradeOnBoot GetRepoUpgradeOnBoot() const { return m_repoUpgradeOnBoot; }
    inline bool RepoUpgradeOnBootHasBeenSet() const { return m_repoUpgradeOnBootHasBeenSet; }
    inline void SetRepoUpgradeOnBoot(RepoUpgradeOnBoot value) { m_repoUpgradeOnBootHasBeenSet = true; m_repoUpgradeOnBoot = value; }
    inline RunJobFlowRequest& WithRepoUpgradeOnBoot(RepoUpgradeOnBoot value) { SetRepoUpgradeOnBoot(value); return *this;}
 
 
    inline const KerberosAttributes& GetKerberosAttributes() const { return m_kerberosAttributes; }
    inline bool KerberosAttributesHasBeenSet() const { return m_kerberosAttributesHasBeenSet; }
    template<typename KerberosAttributesT = KerberosAttributes>
    void SetKerberosAttributes(KerberosAttributesT&& value) { m_kerberosAttributesHasBeenSet = true; m_kerberosAttributes = std::forward<KerberosAttributesT>(value); }
    template<typename KerberosAttributesT = KerberosAttributes>
    RunJobFlowRequest& WithKerberosAttributes(KerberosAttributesT&& value) { SetKerberosAttributes(std::forward<KerberosAttributesT>(value)); return *this;}
 
 
    inline int GetStepConcurrencyLevel() const { return m_stepConcurrencyLevel; }
    inline bool StepConcurrencyLevelHasBeenSet() const { return m_stepConcurrencyLevelHasBeenSet; }
    inline void SetStepConcurrencyLevel(int value) { m_stepConcurrencyLevelHasBeenSet = true; m_stepConcurrencyLevel = value; }
    inline RunJobFlowRequest& WithStepConcurrencyLevel(int value) { SetStepConcurrencyLevel(value); return *this;}
 
 
    inline const ManagedScalingPolicy& GetManagedScalingPolicy() const { return m_managedScalingPolicy; }
    inline bool ManagedScalingPolicyHasBeenSet() const { return m_managedScalingPolicyHasBeenSet; }
    template<typename ManagedScalingPolicyT = ManagedScalingPolicy>
    void SetManagedScalingPolicy(ManagedScalingPolicyT&& value) { m_managedScalingPolicyHasBeenSet = true; m_managedScalingPolicy = std::forward<ManagedScalingPolicyT>(value); }
    template<typename ManagedScalingPolicyT = ManagedScalingPolicy>
    RunJobFlowRequest& WithManagedScalingPolicy(ManagedScalingPolicyT&& value) { SetManagedScalingPolicy(std::forward<ManagedScalingPolicyT>(value)); return *this;}
 
 
    inline const Aws::Vector<PlacementGroupConfig>& GetPlacementGroupConfigs() const { return m_placementGroupConfigs; }
    inline bool PlacementGroupConfigsHasBeenSet() const { return m_placementGroupConfigsHasBeenSet; }
    template<typename PlacementGroupConfigsT = Aws::Vector<PlacementGroupConfig>>
    void SetPlacementGroupConfigs(PlacementGroupConfigsT&& value) { m_placementGroupConfigsHasBeenSet = true; m_placementGroupConfigs = std::forward<PlacementGroupConfigsT>(value); }
    template<typename PlacementGroupConfigsT = Aws::Vector<PlacementGroupConfig>>
    RunJobFlowRequest& WithPlacementGroupConfigs(PlacementGroupConfigsT&& value) { SetPlacementGroupConfigs(std::forward<PlacementGroupConfigsT>(value)); return *this;}
    template<typename PlacementGroupConfigsT = PlacementGroupConfig>
    RunJobFlowRequest& AddPlacementGroupConfigs(PlacementGroupConfigsT&& value) { m_placementGroupConfigsHasBeenSet = true; m_placementGroupConfigs.emplace_back(std::forward<PlacementGroupConfigsT>(value)); return *this; }
 
    
    inline const AutoTerminationPolicy& GetAutoTerminationPolicy() const { return m_autoTerminationPolicy; }
    inline bool AutoTerminationPolicyHasBeenSet() const { return m_autoTerminationPolicyHasBeenSet; }
    template<typename AutoTerminationPolicyT = AutoTerminationPolicy>
    void SetAutoTerminationPolicy(AutoTerminationPolicyT&& value) { m_autoTerminationPolicyHasBeenSet = true; m_autoTerminationPolicy = std::forward<AutoTerminationPolicyT>(value); }
    template<typename AutoTerminationPolicyT = AutoTerminationPolicy>
    RunJobFlowRequest& WithAutoTerminationPolicy(AutoTerminationPolicyT&& value) { SetAutoTerminationPolicy(std::forward<AutoTerminationPolicyT>(value)); return *this;}
 
 
    inline const Aws::String& GetOSReleaseLabel() const { return m_oSReleaseLabel; }
    inline bool OSReleaseLabelHasBeenSet() const { return m_oSReleaseLabelHasBeenSet; }
    template<typename OSReleaseLabelT = Aws::String>
    void SetOSReleaseLabel(OSReleaseLabelT&& value) { m_oSReleaseLabelHasBeenSet = true; m_oSReleaseLabel = std::forward<OSReleaseLabelT>(value); }
    template<typename OSReleaseLabelT = Aws::String>
    RunJobFlowRequest& WithOSReleaseLabel(OSReleaseLabelT&& value) { SetOSReleaseLabel(std::forward<OSReleaseLabelT>(value)); return *this;}
 
 
    inline int GetEbsRootVolumeIops() const { return m_ebsRootVolumeIops; }
    inline bool EbsRootVolumeIopsHasBeenSet() const { return m_ebsRootVolumeIopsHasBeenSet; }
    inline void SetEbsRootVolumeIops(int value) { m_ebsRootVolumeIopsHasBeenSet = true; m_ebsRootVolumeIops = value; }
    inline RunJobFlowRequest& WithEbsRootVolumeIops(int value) { SetEbsRootVolumeIops(value); return *this;}
 
 
    inline int GetEbsRootVolumeThroughput() const { return m_ebsRootVolumeThroughput; }
    inline bool EbsRootVolumeThroughputHasBeenSet() const { return m_ebsRootVolumeThroughputHasBeenSet; }
    inline void SetEbsRootVolumeThroughput(int value) { m_ebsRootVolumeThroughputHasBeenSet = true; m_ebsRootVolumeThroughput = value; }
    inline RunJobFlowRequest& WithEbsRootVolumeThroughput(int value) { SetEbsRootVolumeThroughput(value); return *this;}
  private:
 
    Aws::String m_name;
    bool m_nameHasBeenSet = false;
 
    Aws::String m_logUri;
    bool m_logUriHasBeenSet = false;
 
    Aws::String m_logEncryptionKmsKeyId;
    bool m_logEncryptionKmsKeyIdHasBeenSet = false;
 
    Aws::String m_additionalInfo;
    bool m_additionalInfoHasBeenSet = false;
 
    Aws::String m_amiVersion;
    bool m_amiVersionHasBeenSet = false;
 
    Aws::String m_releaseLabel;
    bool m_releaseLabelHasBeenSet = false;
 
    JobFlowInstancesConfig m_instances;
    bool m_instancesHasBeenSet = false;
 
    Aws::Vector<StepConfig> m_steps;
    bool m_stepsHasBeenSet = false;
 
    Aws::Vector<BootstrapActionConfig> m_bootstrapActions;
    bool m_bootstrapActionsHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_supportedProducts;
    bool m_supportedProductsHasBeenSet = false;
 
    Aws::Vector<SupportedProductConfig> m_newSupportedProducts;
    bool m_newSupportedProductsHasBeenSet = false;
 
    Aws::Vector<Application> m_applications;
    bool m_applicationsHasBeenSet = false;
 
    Aws::Vector<Configuration> m_configurations;
    bool m_configurationsHasBeenSet = false;
 
    bool m_visibleToAllUsers{false};
    bool m_visibleToAllUsersHasBeenSet = false;
 
    Aws::String m_jobFlowRole;
    bool m_jobFlowRoleHasBeenSet = false;
 
    Aws::String m_serviceRole;
    bool m_serviceRoleHasBeenSet = false;
 
    Aws::Vector<Tag> m_tags;
    bool m_tagsHasBeenSet = false;
 
    Aws::String m_securityConfiguration;
    bool m_securityConfigurationHasBeenSet = false;
 
    Aws::String m_autoScalingRole;
    bool m_autoScalingRoleHasBeenSet = false;
 
    ScaleDownBehavior m_scaleDownBehavior{ScaleDownBehavior::NOT_SET};
    bool m_scaleDownBehaviorHasBeenSet = false;
 
    Aws::String m_customAmiId;
    bool m_customAmiIdHasBeenSet = false;
 
    int m_ebsRootVolumeSize{0};
    bool m_ebsRootVolumeSizeHasBeenSet = false;
 
    RepoUpgradeOnBoot m_repoUpgradeOnBoot{RepoUpgradeOnBoot::NOT_SET};
    bool m_repoUpgradeOnBootHasBeenSet = false;
 
    KerberosAttributes m_kerberosAttributes;
    bool m_kerberosAttributesHasBeenSet = false;
 
    int m_stepConcurrencyLevel{0};
    bool m_stepConcurrencyLevelHasBeenSet = false;
 
    ManagedScalingPolicy m_managedScalingPolicy;
    bool m_managedScalingPolicyHasBeenSet = false;
 
    Aws::Vector<PlacementGroupConfig> m_placementGroupConfigs;
    bool m_placementGroupConfigsHasBeenSet = false;
 
    AutoTerminationPolicy m_autoTerminationPolicy;
    bool m_autoTerminationPolicyHasBeenSet = false;
 
    Aws::String m_oSReleaseLabel;
    bool m_oSReleaseLabelHasBeenSet = false;
 
    int m_ebsRootVolumeIops{0};
    bool m_ebsRootVolumeIopsHasBeenSet = false;
 
    int m_ebsRootVolumeThroughput{0};
    bool m_ebsRootVolumeThroughputHasBeenSet = false;
  };
 
} // namespace Model
} // namespace EMR
} // namespace Aws