RunJobFlowRequest.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/elasticmapreduce/EMRRequest.h>
#include <aws/elasticmapreduce/EMR_EXPORTS.h>
#include <aws/elasticmapreduce/model/Application.h>
#include <aws/elasticmapreduce/model/AutoTerminationPolicy.h>
#include <aws/elasticmapreduce/model/BootstrapActionConfig.h>
#include <aws/elasticmapreduce/model/Configuration.h>
#include <aws/elasticmapreduce/model/JobFlowInstancesConfig.h>
#include <aws/elasticmapreduce/model/KerberosAttributes.h>
#include <aws/elasticmapreduce/model/ManagedScalingPolicy.h>
#include <aws/elasticmapreduce/model/MonitoringConfiguration.h>
#include <aws/elasticmapreduce/model/PlacementGroupConfig.h>
#include <aws/elasticmapreduce/model/RepoUpgradeOnBoot.h>
#include <aws/elasticmapreduce/model/ScaleDownBehavior.h>
#include <aws/elasticmapreduce/model/StepConfig.h>
#include <aws/elasticmapreduce/model/SupportedProductConfig.h>
#include <aws/elasticmapreduce/model/Tag.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::String& GetStepExecutionRoleArn() const { return m_stepExecutionRoleArn; }
  inline bool StepExecutionRoleArnHasBeenSet() const { return m_stepExecutionRoleArnHasBeenSet; }
  template <typename StepExecutionRoleArnT = Aws::String>
  void SetStepExecutionRoleArn(StepExecutionRoleArnT&& value) {
    m_stepExecutionRoleArnHasBeenSet = true;
    m_stepExecutionRoleArn = std::forward<StepExecutionRoleArnT>(value);
  }
  template <typename StepExecutionRoleArnT = Aws::String>
  RunJobFlowRequest& WithStepExecutionRoleArn(StepExecutionRoleArnT&& value) {
    SetStepExecutionRoleArn(std::forward<StepExecutionRoleArnT>(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;
  }
 
 
  inline bool GetExtendedSupport() const { return m_extendedSupport; }
  inline bool ExtendedSupportHasBeenSet() const { return m_extendedSupportHasBeenSet; }
  inline void SetExtendedSupport(bool value) {
    m_extendedSupportHasBeenSet = true;
    m_extendedSupport = value;
  }
  inline RunJobFlowRequest& WithExtendedSupport(bool value) {
    SetExtendedSupport(value);
    return *this;
  }
 
 
  inline const MonitoringConfiguration& GetMonitoringConfiguration() const { return m_monitoringConfiguration; }
  inline bool MonitoringConfigurationHasBeenSet() const { return m_monitoringConfigurationHasBeenSet; }
  template <typename MonitoringConfigurationT = MonitoringConfiguration>
  void SetMonitoringConfiguration(MonitoringConfigurationT&& value) {
    m_monitoringConfigurationHasBeenSet = true;
    m_monitoringConfiguration = std::forward<MonitoringConfigurationT>(value);
  }
  template <typename MonitoringConfigurationT = MonitoringConfiguration>
  RunJobFlowRequest& WithMonitoringConfiguration(MonitoringConfigurationT&& value) {
    SetMonitoringConfiguration(std::forward<MonitoringConfigurationT>(value));
    return *this;
  }
 private:
  Aws::String m_name;
 
  Aws::String m_logUri;
 
  Aws::String m_logEncryptionKmsKeyId;
 
  Aws::String m_additionalInfo;
 
  Aws::String m_amiVersion;
 
  Aws::String m_releaseLabel;
 
  JobFlowInstancesConfig m_instances;
 
  Aws::Vector<StepConfig> m_steps;
 
  Aws::String m_stepExecutionRoleArn;
 
  Aws::Vector<BootstrapActionConfig> m_bootstrapActions;
 
  Aws::Vector<Aws::String> m_supportedProducts;
 
  Aws::Vector<SupportedProductConfig> m_newSupportedProducts;
 
  Aws::Vector<Application> m_applications;
 
  Aws::Vector<Configuration> m_configurations;
 
  bool m_visibleToAllUsers{false};
 
  Aws::String m_jobFlowRole;
 
  Aws::String m_serviceRole;
 
  Aws::Vector<Tag> m_tags;
 
  Aws::String m_securityConfiguration;
 
  Aws::String m_autoScalingRole;
 
  ScaleDownBehavior m_scaleDownBehavior{ScaleDownBehavior::NOT_SET};
 
  Aws::String m_customAmiId;
 
  int m_ebsRootVolumeSize{0};
 
  RepoUpgradeOnBoot m_repoUpgradeOnBoot{RepoUpgradeOnBoot::NOT_SET};
 
  KerberosAttributes m_kerberosAttributes;
 
  int m_stepConcurrencyLevel{0};
 
  ManagedScalingPolicy m_managedScalingPolicy;
 
  Aws::Vector<PlacementGroupConfig> m_placementGroupConfigs;
 
  AutoTerminationPolicy m_autoTerminationPolicy;
 
  Aws::String m_oSReleaseLabel;
 
  int m_ebsRootVolumeIops{0};
 
  int m_ebsRootVolumeThroughput{0};
 
  bool m_extendedSupport{false};
 
  MonitoringConfiguration m_monitoringConfiguration;
  bool m_nameHasBeenSet = false;
  bool m_logUriHasBeenSet = false;
  bool m_logEncryptionKmsKeyIdHasBeenSet = false;
  bool m_additionalInfoHasBeenSet = false;
  bool m_amiVersionHasBeenSet = false;
  bool m_releaseLabelHasBeenSet = false;
  bool m_instancesHasBeenSet = false;
  bool m_stepsHasBeenSet = false;
  bool m_stepExecutionRoleArnHasBeenSet = false;
  bool m_bootstrapActionsHasBeenSet = false;
  bool m_supportedProductsHasBeenSet = false;
  bool m_newSupportedProductsHasBeenSet = false;
  bool m_applicationsHasBeenSet = false;
  bool m_configurationsHasBeenSet = false;
  bool m_visibleToAllUsersHasBeenSet = false;
  bool m_jobFlowRoleHasBeenSet = false;
  bool m_serviceRoleHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_securityConfigurationHasBeenSet = false;
  bool m_autoScalingRoleHasBeenSet = false;
  bool m_scaleDownBehaviorHasBeenSet = false;
  bool m_customAmiIdHasBeenSet = false;
  bool m_ebsRootVolumeSizeHasBeenSet = false;
  bool m_repoUpgradeOnBootHasBeenSet = false;
  bool m_kerberosAttributesHasBeenSet = false;
  bool m_stepConcurrencyLevelHasBeenSet = false;
  bool m_managedScalingPolicyHasBeenSet = false;
  bool m_placementGroupConfigsHasBeenSet = false;
  bool m_autoTerminationPolicyHasBeenSet = false;
  bool m_oSReleaseLabelHasBeenSet = false;
  bool m_ebsRootVolumeIopsHasBeenSet = false;
  bool m_ebsRootVolumeThroughputHasBeenSet = false;
  bool m_extendedSupportHasBeenSet = false;
  bool m_monitoringConfigurationHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace EMR
}  // namespace Aws