EMRClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/elasticmapreduce/EMRPaginationBase.h>
#include <aws/elasticmapreduce/EMRServiceClientModel.h>
#include <aws/elasticmapreduce/EMRWaiter.h>
#include <aws/elasticmapreduce/EMR_EXPORTS.h>
 
namespace Aws {
namespace EMR {
class AWS_EMR_API EMRClient : public Aws::Client::AWSJsonClient,
                              public Aws::Client::ClientWithAsyncTemplateMethods<EMRClient>,
                              public EMRPaginationBase<EMRClient>,
                              public EMRWaiter<EMRClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef EMRClientConfiguration ClientConfigurationType;
  typedef EMREndpointProvider EndpointProviderType;
 
  EMRClient(const Aws::EMR::EMRClientConfiguration& clientConfiguration = Aws::EMR::EMRClientConfiguration(),
            std::shared_ptr<EMREndpointProviderBase> endpointProvider = nullptr);
 
  EMRClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<EMREndpointProviderBase> endpointProvider = nullptr,
            const Aws::EMR::EMRClientConfiguration& clientConfiguration = Aws::EMR::EMRClientConfiguration());
 
  EMRClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            std::shared_ptr<EMREndpointProviderBase> endpointProvider = nullptr,
            const Aws::EMR::EMRClientConfiguration& clientConfiguration = Aws::EMR::EMRClientConfiguration());
 
  /* Legacy constructors due deprecation */
  EMRClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  EMRClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  EMRClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~EMRClient();
 
  virtual Model::AddInstanceFleetOutcome AddInstanceFleet(const Model::AddInstanceFleetRequest& request) const;
 
  template <typename AddInstanceFleetRequestT = Model::AddInstanceFleetRequest>
  Model::AddInstanceFleetOutcomeCallable AddInstanceFleetCallable(const AddInstanceFleetRequestT& request) const {
    return SubmitCallable(&EMRClient::AddInstanceFleet, request);
  }
 
  template <typename AddInstanceFleetRequestT = Model::AddInstanceFleetRequest>
  void AddInstanceFleetAsync(const AddInstanceFleetRequestT& request, const AddInstanceFleetResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::AddInstanceFleet, request, handler, context);
  }
 
  virtual Model::AddInstanceGroupsOutcome AddInstanceGroups(const Model::AddInstanceGroupsRequest& request) const;
 
  template <typename AddInstanceGroupsRequestT = Model::AddInstanceGroupsRequest>
  Model::AddInstanceGroupsOutcomeCallable AddInstanceGroupsCallable(const AddInstanceGroupsRequestT& request) const {
    return SubmitCallable(&EMRClient::AddInstanceGroups, request);
  }
 
  template <typename AddInstanceGroupsRequestT = Model::AddInstanceGroupsRequest>
  void AddInstanceGroupsAsync(const AddInstanceGroupsRequestT& request, const AddInstanceGroupsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::AddInstanceGroups, request, handler, context);
  }
 
  virtual Model::AddJobFlowStepsOutcome AddJobFlowSteps(const Model::AddJobFlowStepsRequest& request) const;
 
  template <typename AddJobFlowStepsRequestT = Model::AddJobFlowStepsRequest>
  Model::AddJobFlowStepsOutcomeCallable AddJobFlowStepsCallable(const AddJobFlowStepsRequestT& request) const {
    return SubmitCallable(&EMRClient::AddJobFlowSteps, request);
  }
 
  template <typename AddJobFlowStepsRequestT = Model::AddJobFlowStepsRequest>
  void AddJobFlowStepsAsync(const AddJobFlowStepsRequestT& request, const AddJobFlowStepsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::AddJobFlowSteps, request, handler, context);
  }
 
  virtual Model::AddTagsOutcome AddTags(const Model::AddTagsRequest& request) const;
 
  template <typename AddTagsRequestT = Model::AddTagsRequest>
  Model::AddTagsOutcomeCallable AddTagsCallable(const AddTagsRequestT& request) const {
    return SubmitCallable(&EMRClient::AddTags, request);
  }
 
  template <typename AddTagsRequestT = Model::AddTagsRequest>
  void AddTagsAsync(const AddTagsRequestT& request, const AddTagsResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::AddTags, request, handler, context);
  }
 
  virtual Model::CancelStepsOutcome CancelSteps(const Model::CancelStepsRequest& request) const;
 
  template <typename CancelStepsRequestT = Model::CancelStepsRequest>
  Model::CancelStepsOutcomeCallable CancelStepsCallable(const CancelStepsRequestT& request) const {
    return SubmitCallable(&EMRClient::CancelSteps, request);
  }
 
  template <typename CancelStepsRequestT = Model::CancelStepsRequest>
  void CancelStepsAsync(const CancelStepsRequestT& request, const CancelStepsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::CancelSteps, request, handler, context);
  }
 
  virtual Model::CreatePersistentAppUIOutcome CreatePersistentAppUI(const Model::CreatePersistentAppUIRequest& request) const;
 
  template <typename CreatePersistentAppUIRequestT = Model::CreatePersistentAppUIRequest>
  Model::CreatePersistentAppUIOutcomeCallable CreatePersistentAppUICallable(const CreatePersistentAppUIRequestT& request) const {
    return SubmitCallable(&EMRClient::CreatePersistentAppUI, request);
  }
 
  template <typename CreatePersistentAppUIRequestT = Model::CreatePersistentAppUIRequest>
  void CreatePersistentAppUIAsync(const CreatePersistentAppUIRequestT& request, const CreatePersistentAppUIResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::CreatePersistentAppUI, request, handler, context);
  }
 
  virtual Model::CreateSecurityConfigurationOutcome CreateSecurityConfiguration(
      const Model::CreateSecurityConfigurationRequest& request) const;
 
  template <typename CreateSecurityConfigurationRequestT = Model::CreateSecurityConfigurationRequest>
  Model::CreateSecurityConfigurationOutcomeCallable CreateSecurityConfigurationCallable(
      const CreateSecurityConfigurationRequestT& request) const {
    return SubmitCallable(&EMRClient::CreateSecurityConfiguration, request);
  }
 
  template <typename CreateSecurityConfigurationRequestT = Model::CreateSecurityConfigurationRequest>
  void CreateSecurityConfigurationAsync(const CreateSecurityConfigurationRequestT& request,
                                        const CreateSecurityConfigurationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::CreateSecurityConfiguration, request, handler, context);
  }
 
  virtual Model::CreateStudioOutcome CreateStudio(const Model::CreateStudioRequest& request) const;
 
  template <typename CreateStudioRequestT = Model::CreateStudioRequest>
  Model::CreateStudioOutcomeCallable CreateStudioCallable(const CreateStudioRequestT& request) const {
    return SubmitCallable(&EMRClient::CreateStudio, request);
  }
 
  template <typename CreateStudioRequestT = Model::CreateStudioRequest>
  void CreateStudioAsync(const CreateStudioRequestT& request, const CreateStudioResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::CreateStudio, request, handler, context);
  }
 
  virtual Model::CreateStudioSessionMappingOutcome CreateStudioSessionMapping(
      const Model::CreateStudioSessionMappingRequest& request) const;
 
  template <typename CreateStudioSessionMappingRequestT = Model::CreateStudioSessionMappingRequest>
  Model::CreateStudioSessionMappingOutcomeCallable CreateStudioSessionMappingCallable(
      const CreateStudioSessionMappingRequestT& request) const {
    return SubmitCallable(&EMRClient::CreateStudioSessionMapping, request);
  }
 
  template <typename CreateStudioSessionMappingRequestT = Model::CreateStudioSessionMappingRequest>
  void CreateStudioSessionMappingAsync(const CreateStudioSessionMappingRequestT& request,
                                       const CreateStudioSessionMappingResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::CreateStudioSessionMapping, request, handler, context);
  }
 
  virtual Model::DeleteSecurityConfigurationOutcome DeleteSecurityConfiguration(
      const Model::DeleteSecurityConfigurationRequest& request) const;
 
  template <typename DeleteSecurityConfigurationRequestT = Model::DeleteSecurityConfigurationRequest>
  Model::DeleteSecurityConfigurationOutcomeCallable DeleteSecurityConfigurationCallable(
      const DeleteSecurityConfigurationRequestT& request) const {
    return SubmitCallable(&EMRClient::DeleteSecurityConfiguration, request);
  }
 
  template <typename DeleteSecurityConfigurationRequestT = Model::DeleteSecurityConfigurationRequest>
  void DeleteSecurityConfigurationAsync(const DeleteSecurityConfigurationRequestT& request,
                                        const DeleteSecurityConfigurationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::DeleteSecurityConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteStudioOutcome DeleteStudio(const Model::DeleteStudioRequest& request) const;
 
  template <typename DeleteStudioRequestT = Model::DeleteStudioRequest>
  Model::DeleteStudioOutcomeCallable DeleteStudioCallable(const DeleteStudioRequestT& request) const {
    return SubmitCallable(&EMRClient::DeleteStudio, request);
  }
 
  template <typename DeleteStudioRequestT = Model::DeleteStudioRequest>
  void DeleteStudioAsync(const DeleteStudioRequestT& request, const DeleteStudioResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::DeleteStudio, request, handler, context);
  }
 
  virtual Model::DeleteStudioSessionMappingOutcome DeleteStudioSessionMapping(
      const Model::DeleteStudioSessionMappingRequest& request) const;
 
  template <typename DeleteStudioSessionMappingRequestT = Model::DeleteStudioSessionMappingRequest>
  Model::DeleteStudioSessionMappingOutcomeCallable DeleteStudioSessionMappingCallable(
      const DeleteStudioSessionMappingRequestT& request) const {
    return SubmitCallable(&EMRClient::DeleteStudioSessionMapping, request);
  }
 
  template <typename DeleteStudioSessionMappingRequestT = Model::DeleteStudioSessionMappingRequest>
  void DeleteStudioSessionMappingAsync(const DeleteStudioSessionMappingRequestT& request,
                                       const DeleteStudioSessionMappingResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::DeleteStudioSessionMapping, request, handler, context);
  }
 
  virtual Model::DescribeClusterOutcome DescribeCluster(const Model::DescribeClusterRequest& request) const;
 
  template <typename DescribeClusterRequestT = Model::DescribeClusterRequest>
  Model::DescribeClusterOutcomeCallable DescribeClusterCallable(const DescribeClusterRequestT& request) const {
    return SubmitCallable(&EMRClient::DescribeCluster, request);
  }
 
  template <typename DescribeClusterRequestT = Model::DescribeClusterRequest>
  void DescribeClusterAsync(const DescribeClusterRequestT& request, const DescribeClusterResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::DescribeCluster, request, handler, context);
  }
 
  virtual Model::DescribeNotebookExecutionOutcome DescribeNotebookExecution(const Model::DescribeNotebookExecutionRequest& request) const;
 
  template <typename DescribeNotebookExecutionRequestT = Model::DescribeNotebookExecutionRequest>
  Model::DescribeNotebookExecutionOutcomeCallable DescribeNotebookExecutionCallable(
      const DescribeNotebookExecutionRequestT& request) const {
    return SubmitCallable(&EMRClient::DescribeNotebookExecution, request);
  }
 
  template <typename DescribeNotebookExecutionRequestT = Model::DescribeNotebookExecutionRequest>
  void DescribeNotebookExecutionAsync(const DescribeNotebookExecutionRequestT& request,
                                      const DescribeNotebookExecutionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::DescribeNotebookExecution, request, handler, context);
  }
 
  virtual Model::DescribePersistentAppUIOutcome DescribePersistentAppUI(const Model::DescribePersistentAppUIRequest& request) const;
 
  template <typename DescribePersistentAppUIRequestT = Model::DescribePersistentAppUIRequest>
  Model::DescribePersistentAppUIOutcomeCallable DescribePersistentAppUICallable(const DescribePersistentAppUIRequestT& request) const {
    return SubmitCallable(&EMRClient::DescribePersistentAppUI, request);
  }
 
  template <typename DescribePersistentAppUIRequestT = Model::DescribePersistentAppUIRequest>
  void DescribePersistentAppUIAsync(const DescribePersistentAppUIRequestT& request,
                                    const DescribePersistentAppUIResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::DescribePersistentAppUI, request, handler, context);
  }
 
  virtual Model::DescribeReleaseLabelOutcome DescribeReleaseLabel(const Model::DescribeReleaseLabelRequest& request = {}) const;
 
  template <typename DescribeReleaseLabelRequestT = Model::DescribeReleaseLabelRequest>
  Model::DescribeReleaseLabelOutcomeCallable DescribeReleaseLabelCallable(const DescribeReleaseLabelRequestT& request = {}) const {
    return SubmitCallable(&EMRClient::DescribeReleaseLabel, request);
  }
 
  template <typename DescribeReleaseLabelRequestT = Model::DescribeReleaseLabelRequest>
  void DescribeReleaseLabelAsync(const DescribeReleaseLabelResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const DescribeReleaseLabelRequestT& request = {}) const {
    return SubmitAsync(&EMRClient::DescribeReleaseLabel, request, handler, context);
  }
 
  virtual Model::DescribeSecurityConfigurationOutcome DescribeSecurityConfiguration(
      const Model::DescribeSecurityConfigurationRequest& request) const;
 
  template <typename DescribeSecurityConfigurationRequestT = Model::DescribeSecurityConfigurationRequest>
  Model::DescribeSecurityConfigurationOutcomeCallable DescribeSecurityConfigurationCallable(
      const DescribeSecurityConfigurationRequestT& request) const {
    return SubmitCallable(&EMRClient::DescribeSecurityConfiguration, request);
  }
 
  template <typename DescribeSecurityConfigurationRequestT = Model::DescribeSecurityConfigurationRequest>
  void DescribeSecurityConfigurationAsync(const DescribeSecurityConfigurationRequestT& request,
                                          const DescribeSecurityConfigurationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::DescribeSecurityConfiguration, request, handler, context);
  }
 
  virtual Model::DescribeStepOutcome DescribeStep(const Model::DescribeStepRequest& request) const;
 
  template <typename DescribeStepRequestT = Model::DescribeStepRequest>
  Model::DescribeStepOutcomeCallable DescribeStepCallable(const DescribeStepRequestT& request) const {
    return SubmitCallable(&EMRClient::DescribeStep, request);
  }
 
  template <typename DescribeStepRequestT = Model::DescribeStepRequest>
  void DescribeStepAsync(const DescribeStepRequestT& request, const DescribeStepResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::DescribeStep, request, handler, context);
  }
 
  virtual Model::DescribeStudioOutcome DescribeStudio(const Model::DescribeStudioRequest& request) const;
 
  template <typename DescribeStudioRequestT = Model::DescribeStudioRequest>
  Model::DescribeStudioOutcomeCallable DescribeStudioCallable(const DescribeStudioRequestT& request) const {
    return SubmitCallable(&EMRClient::DescribeStudio, request);
  }
 
  template <typename DescribeStudioRequestT = Model::DescribeStudioRequest>
  void DescribeStudioAsync(const DescribeStudioRequestT& request, const DescribeStudioResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::DescribeStudio, request, handler, context);
  }
 
  virtual Model::GetAutoTerminationPolicyOutcome GetAutoTerminationPolicy(const Model::GetAutoTerminationPolicyRequest& request) const;
 
  template <typename GetAutoTerminationPolicyRequestT = Model::GetAutoTerminationPolicyRequest>
  Model::GetAutoTerminationPolicyOutcomeCallable GetAutoTerminationPolicyCallable(const GetAutoTerminationPolicyRequestT& request) const {
    return SubmitCallable(&EMRClient::GetAutoTerminationPolicy, request);
  }
 
  template <typename GetAutoTerminationPolicyRequestT = Model::GetAutoTerminationPolicyRequest>
  void GetAutoTerminationPolicyAsync(const GetAutoTerminationPolicyRequestT& request,
                                     const GetAutoTerminationPolicyResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::GetAutoTerminationPolicy, request, handler, context);
  }
 
  virtual Model::GetBlockPublicAccessConfigurationOutcome GetBlockPublicAccessConfiguration(
      const Model::GetBlockPublicAccessConfigurationRequest& request = {}) const;
 
  template <typename GetBlockPublicAccessConfigurationRequestT = Model::GetBlockPublicAccessConfigurationRequest>
  Model::GetBlockPublicAccessConfigurationOutcomeCallable GetBlockPublicAccessConfigurationCallable(
      const GetBlockPublicAccessConfigurationRequestT& request = {}) const {
    return SubmitCallable(&EMRClient::GetBlockPublicAccessConfiguration, request);
  }
 
  template <typename GetBlockPublicAccessConfigurationRequestT = Model::GetBlockPublicAccessConfigurationRequest>
  void GetBlockPublicAccessConfigurationAsync(const GetBlockPublicAccessConfigurationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const GetBlockPublicAccessConfigurationRequestT& request = {}) const {
    return SubmitAsync(&EMRClient::GetBlockPublicAccessConfiguration, request, handler, context);
  }
 
  virtual Model::GetClusterSessionCredentialsOutcome GetClusterSessionCredentials(
      const Model::GetClusterSessionCredentialsRequest& request) const;
 
  template <typename GetClusterSessionCredentialsRequestT = Model::GetClusterSessionCredentialsRequest>
  Model::GetClusterSessionCredentialsOutcomeCallable GetClusterSessionCredentialsCallable(
      const GetClusterSessionCredentialsRequestT& request) const {
    return SubmitCallable(&EMRClient::GetClusterSessionCredentials, request);
  }
 
  template <typename GetClusterSessionCredentialsRequestT = Model::GetClusterSessionCredentialsRequest>
  void GetClusterSessionCredentialsAsync(const GetClusterSessionCredentialsRequestT& request,
                                         const GetClusterSessionCredentialsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::GetClusterSessionCredentials, request, handler, context);
  }
 
  virtual Model::GetManagedScalingPolicyOutcome GetManagedScalingPolicy(const Model::GetManagedScalingPolicyRequest& request) const;
 
  template <typename GetManagedScalingPolicyRequestT = Model::GetManagedScalingPolicyRequest>
  Model::GetManagedScalingPolicyOutcomeCallable GetManagedScalingPolicyCallable(const GetManagedScalingPolicyRequestT& request) const {
    return SubmitCallable(&EMRClient::GetManagedScalingPolicy, request);
  }
 
  template <typename GetManagedScalingPolicyRequestT = Model::GetManagedScalingPolicyRequest>
  void GetManagedScalingPolicyAsync(const GetManagedScalingPolicyRequestT& request,
                                    const GetManagedScalingPolicyResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::GetManagedScalingPolicy, request, handler, context);
  }
 
  virtual Model::GetOnClusterAppUIPresignedURLOutcome GetOnClusterAppUIPresignedURL(
      const Model::GetOnClusterAppUIPresignedURLRequest& request) const;
 
  template <typename GetOnClusterAppUIPresignedURLRequestT = Model::GetOnClusterAppUIPresignedURLRequest>
  Model::GetOnClusterAppUIPresignedURLOutcomeCallable GetOnClusterAppUIPresignedURLCallable(
      const GetOnClusterAppUIPresignedURLRequestT& request) const {
    return SubmitCallable(&EMRClient::GetOnClusterAppUIPresignedURL, request);
  }
 
  template <typename GetOnClusterAppUIPresignedURLRequestT = Model::GetOnClusterAppUIPresignedURLRequest>
  void GetOnClusterAppUIPresignedURLAsync(const GetOnClusterAppUIPresignedURLRequestT& request,
                                          const GetOnClusterAppUIPresignedURLResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::GetOnClusterAppUIPresignedURL, request, handler, context);
  }
 
  virtual Model::GetPersistentAppUIPresignedURLOutcome GetPersistentAppUIPresignedURL(
      const Model::GetPersistentAppUIPresignedURLRequest& request) const;
 
  template <typename GetPersistentAppUIPresignedURLRequestT = Model::GetPersistentAppUIPresignedURLRequest>
  Model::GetPersistentAppUIPresignedURLOutcomeCallable GetPersistentAppUIPresignedURLCallable(
      const GetPersistentAppUIPresignedURLRequestT& request) const {
    return SubmitCallable(&EMRClient::GetPersistentAppUIPresignedURL, request);
  }
 
  template <typename GetPersistentAppUIPresignedURLRequestT = Model::GetPersistentAppUIPresignedURLRequest>
  void GetPersistentAppUIPresignedURLAsync(const GetPersistentAppUIPresignedURLRequestT& request,
                                           const GetPersistentAppUIPresignedURLResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::GetPersistentAppUIPresignedURL, request, handler, context);
  }
 
  virtual Model::GetSessionOutcome GetSession(const Model::GetSessionRequest& request) const;
 
  template <typename GetSessionRequestT = Model::GetSessionRequest>
  Model::GetSessionOutcomeCallable GetSessionCallable(const GetSessionRequestT& request) const {
    return SubmitCallable(&EMRClient::GetSession, request);
  }
 
  template <typename GetSessionRequestT = Model::GetSessionRequest>
  void GetSessionAsync(const GetSessionRequestT& request, const GetSessionResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::GetSession, request, handler, context);
  }
 
  virtual Model::GetSessionEndpointOutcome GetSessionEndpoint(const Model::GetSessionEndpointRequest& request) const;
 
  template <typename GetSessionEndpointRequestT = Model::GetSessionEndpointRequest>
  Model::GetSessionEndpointOutcomeCallable GetSessionEndpointCallable(const GetSessionEndpointRequestT& request) const {
    return SubmitCallable(&EMRClient::GetSessionEndpoint, request);
  }
 
  template <typename GetSessionEndpointRequestT = Model::GetSessionEndpointRequest>
  void GetSessionEndpointAsync(const GetSessionEndpointRequestT& request, const GetSessionEndpointResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::GetSessionEndpoint, request, handler, context);
  }
 
  virtual Model::GetStudioSessionMappingOutcome GetStudioSessionMapping(const Model::GetStudioSessionMappingRequest& request) const;
 
  template <typename GetStudioSessionMappingRequestT = Model::GetStudioSessionMappingRequest>
  Model::GetStudioSessionMappingOutcomeCallable GetStudioSessionMappingCallable(const GetStudioSessionMappingRequestT& request) const {
    return SubmitCallable(&EMRClient::GetStudioSessionMapping, request);
  }
 
  template <typename GetStudioSessionMappingRequestT = Model::GetStudioSessionMappingRequest>
  void GetStudioSessionMappingAsync(const GetStudioSessionMappingRequestT& request,
                                    const GetStudioSessionMappingResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::GetStudioSessionMapping, request, handler, context);
  }
 
  virtual Model::ListBootstrapActionsOutcome ListBootstrapActions(const Model::ListBootstrapActionsRequest& request) const;
 
  template <typename ListBootstrapActionsRequestT = Model::ListBootstrapActionsRequest>
  Model::ListBootstrapActionsOutcomeCallable ListBootstrapActionsCallable(const ListBootstrapActionsRequestT& request) const {
    return SubmitCallable(&EMRClient::ListBootstrapActions, request);
  }
 
  template <typename ListBootstrapActionsRequestT = Model::ListBootstrapActionsRequest>
  void ListBootstrapActionsAsync(const ListBootstrapActionsRequestT& request, const ListBootstrapActionsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::ListBootstrapActions, request, handler, context);
  }
 
  virtual Model::ListClustersOutcome ListClusters(const Model::ListClustersRequest& request = {}) const;
 
  template <typename ListClustersRequestT = Model::ListClustersRequest>
  Model::ListClustersOutcomeCallable ListClustersCallable(const ListClustersRequestT& request = {}) const {
    return SubmitCallable(&EMRClient::ListClusters, request);
  }
 
  template <typename ListClustersRequestT = Model::ListClustersRequest>
  void ListClustersAsync(const ListClustersResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListClustersRequestT& request = {}) const {
    return SubmitAsync(&EMRClient::ListClusters, request, handler, context);
  }
 
  virtual Model::ListInstanceFleetsOutcome ListInstanceFleets(const Model::ListInstanceFleetsRequest& request) const;
 
  template <typename ListInstanceFleetsRequestT = Model::ListInstanceFleetsRequest>
  Model::ListInstanceFleetsOutcomeCallable ListInstanceFleetsCallable(const ListInstanceFleetsRequestT& request) const {
    return SubmitCallable(&EMRClient::ListInstanceFleets, request);
  }
 
  template <typename ListInstanceFleetsRequestT = Model::ListInstanceFleetsRequest>
  void ListInstanceFleetsAsync(const ListInstanceFleetsRequestT& request, const ListInstanceFleetsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::ListInstanceFleets, request, handler, context);
  }
 
  virtual Model::ListInstanceGroupsOutcome ListInstanceGroups(const Model::ListInstanceGroupsRequest& request) const;
 
  template <typename ListInstanceGroupsRequestT = Model::ListInstanceGroupsRequest>
  Model::ListInstanceGroupsOutcomeCallable ListInstanceGroupsCallable(const ListInstanceGroupsRequestT& request) const {
    return SubmitCallable(&EMRClient::ListInstanceGroups, request);
  }
 
  template <typename ListInstanceGroupsRequestT = Model::ListInstanceGroupsRequest>
  void ListInstanceGroupsAsync(const ListInstanceGroupsRequestT& request, const ListInstanceGroupsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::ListInstanceGroups, request, handler, context);
  }
 
  virtual Model::ListInstancesOutcome ListInstances(const Model::ListInstancesRequest& request) const;
 
  template <typename ListInstancesRequestT = Model::ListInstancesRequest>
  Model::ListInstancesOutcomeCallable ListInstancesCallable(const ListInstancesRequestT& request) const {
    return SubmitCallable(&EMRClient::ListInstances, request);
  }
 
  template <typename ListInstancesRequestT = Model::ListInstancesRequest>
  void ListInstancesAsync(const ListInstancesRequestT& request, const ListInstancesResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::ListInstances, request, handler, context);
  }
 
  virtual Model::ListNotebookExecutionsOutcome ListNotebookExecutions(const Model::ListNotebookExecutionsRequest& request = {}) const;
 
  template <typename ListNotebookExecutionsRequestT = Model::ListNotebookExecutionsRequest>
  Model::ListNotebookExecutionsOutcomeCallable ListNotebookExecutionsCallable(const ListNotebookExecutionsRequestT& request = {}) const {
    return SubmitCallable(&EMRClient::ListNotebookExecutions, request);
  }
 
  template <typename ListNotebookExecutionsRequestT = Model::ListNotebookExecutionsRequest>
  void ListNotebookExecutionsAsync(const ListNotebookExecutionsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListNotebookExecutionsRequestT& request = {}) const {
    return SubmitAsync(&EMRClient::ListNotebookExecutions, request, handler, context);
  }
 
  virtual Model::ListReleaseLabelsOutcome ListReleaseLabels(const Model::ListReleaseLabelsRequest& request = {}) const;
 
  template <typename ListReleaseLabelsRequestT = Model::ListReleaseLabelsRequest>
  Model::ListReleaseLabelsOutcomeCallable ListReleaseLabelsCallable(const ListReleaseLabelsRequestT& request = {}) const {
    return SubmitCallable(&EMRClient::ListReleaseLabels, request);
  }
 
  template <typename ListReleaseLabelsRequestT = Model::ListReleaseLabelsRequest>
  void ListReleaseLabelsAsync(const ListReleaseLabelsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListReleaseLabelsRequestT& request = {}) const {
    return SubmitAsync(&EMRClient::ListReleaseLabels, request, handler, context);
  }
 
  virtual Model::ListSecurityConfigurationsOutcome ListSecurityConfigurations(
      const Model::ListSecurityConfigurationsRequest& request = {}) const;
 
  template <typename ListSecurityConfigurationsRequestT = Model::ListSecurityConfigurationsRequest>
  Model::ListSecurityConfigurationsOutcomeCallable ListSecurityConfigurationsCallable(
      const ListSecurityConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&EMRClient::ListSecurityConfigurations, request);
  }
 
  template <typename ListSecurityConfigurationsRequestT = Model::ListSecurityConfigurationsRequest>
  void ListSecurityConfigurationsAsync(const ListSecurityConfigurationsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const ListSecurityConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&EMRClient::ListSecurityConfigurations, request, handler, context);
  }
 
  virtual Model::ListSessionsOutcome ListSessions(const Model::ListSessionsRequest& request) const;
 
  template <typename ListSessionsRequestT = Model::ListSessionsRequest>
  Model::ListSessionsOutcomeCallable ListSessionsCallable(const ListSessionsRequestT& request) const {
    return SubmitCallable(&EMRClient::ListSessions, request);
  }
 
  template <typename ListSessionsRequestT = Model::ListSessionsRequest>
  void ListSessionsAsync(const ListSessionsRequestT& request, const ListSessionsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::ListSessions, request, handler, context);
  }
 
  virtual Model::ListStepsOutcome ListSteps(const Model::ListStepsRequest& request) const;
 
  template <typename ListStepsRequestT = Model::ListStepsRequest>
  Model::ListStepsOutcomeCallable ListStepsCallable(const ListStepsRequestT& request) const {
    return SubmitCallable(&EMRClient::ListSteps, request);
  }
 
  template <typename ListStepsRequestT = Model::ListStepsRequest>
  void ListStepsAsync(const ListStepsRequestT& request, const ListStepsResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::ListSteps, request, handler, context);
  }
 
  virtual Model::ListStudioSessionMappingsOutcome ListStudioSessionMappings(
      const Model::ListStudioSessionMappingsRequest& request = {}) const;
 
  template <typename ListStudioSessionMappingsRequestT = Model::ListStudioSessionMappingsRequest>
  Model::ListStudioSessionMappingsOutcomeCallable ListStudioSessionMappingsCallable(
      const ListStudioSessionMappingsRequestT& request = {}) const {
    return SubmitCallable(&EMRClient::ListStudioSessionMappings, request);
  }
 
  template <typename ListStudioSessionMappingsRequestT = Model::ListStudioSessionMappingsRequest>
  void ListStudioSessionMappingsAsync(const ListStudioSessionMappingsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ListStudioSessionMappingsRequestT& request = {}) const {
    return SubmitAsync(&EMRClient::ListStudioSessionMappings, request, handler, context);
  }
 
  virtual Model::ListStudiosOutcome ListStudios(const Model::ListStudiosRequest& request = {}) const;
 
  template <typename ListStudiosRequestT = Model::ListStudiosRequest>
  Model::ListStudiosOutcomeCallable ListStudiosCallable(const ListStudiosRequestT& request = {}) const {
    return SubmitCallable(&EMRClient::ListStudios, request);
  }
 
  template <typename ListStudiosRequestT = Model::ListStudiosRequest>
  void ListStudiosAsync(const ListStudiosResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListStudiosRequestT& request = {}) const {
    return SubmitAsync(&EMRClient::ListStudios, request, handler, context);
  }
 
  virtual Model::ListSupportedInstanceTypesOutcome ListSupportedInstanceTypes(
      const Model::ListSupportedInstanceTypesRequest& request) const;
 
  template <typename ListSupportedInstanceTypesRequestT = Model::ListSupportedInstanceTypesRequest>
  Model::ListSupportedInstanceTypesOutcomeCallable ListSupportedInstanceTypesCallable(
      const ListSupportedInstanceTypesRequestT& request) const {
    return SubmitCallable(&EMRClient::ListSupportedInstanceTypes, request);
  }
 
  template <typename ListSupportedInstanceTypesRequestT = Model::ListSupportedInstanceTypesRequest>
  void ListSupportedInstanceTypesAsync(const ListSupportedInstanceTypesRequestT& request,
                                       const ListSupportedInstanceTypesResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::ListSupportedInstanceTypes, request, handler, context);
  }
 
  virtual Model::ModifyClusterOutcome ModifyCluster(const Model::ModifyClusterRequest& request) const;
 
  template <typename ModifyClusterRequestT = Model::ModifyClusterRequest>
  Model::ModifyClusterOutcomeCallable ModifyClusterCallable(const ModifyClusterRequestT& request) const {
    return SubmitCallable(&EMRClient::ModifyCluster, request);
  }
 
  template <typename ModifyClusterRequestT = Model::ModifyClusterRequest>
  void ModifyClusterAsync(const ModifyClusterRequestT& request, const ModifyClusterResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::ModifyCluster, request, handler, context);
  }
 
  virtual Model::ModifyInstanceFleetOutcome ModifyInstanceFleet(const Model::ModifyInstanceFleetRequest& request) const;
 
  template <typename ModifyInstanceFleetRequestT = Model::ModifyInstanceFleetRequest>
  Model::ModifyInstanceFleetOutcomeCallable ModifyInstanceFleetCallable(const ModifyInstanceFleetRequestT& request) const {
    return SubmitCallable(&EMRClient::ModifyInstanceFleet, request);
  }
 
  template <typename ModifyInstanceFleetRequestT = Model::ModifyInstanceFleetRequest>
  void ModifyInstanceFleetAsync(const ModifyInstanceFleetRequestT& request, const ModifyInstanceFleetResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::ModifyInstanceFleet, request, handler, context);
  }
 
  virtual Model::ModifyInstanceGroupsOutcome ModifyInstanceGroups(const Model::ModifyInstanceGroupsRequest& request = {}) const;
 
  template <typename ModifyInstanceGroupsRequestT = Model::ModifyInstanceGroupsRequest>
  Model::ModifyInstanceGroupsOutcomeCallable ModifyInstanceGroupsCallable(const ModifyInstanceGroupsRequestT& request = {}) const {
    return SubmitCallable(&EMRClient::ModifyInstanceGroups, request);
  }
 
  template <typename ModifyInstanceGroupsRequestT = Model::ModifyInstanceGroupsRequest>
  void ModifyInstanceGroupsAsync(const ModifyInstanceGroupsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ModifyInstanceGroupsRequestT& request = {}) const {
    return SubmitAsync(&EMRClient::ModifyInstanceGroups, request, handler, context);
  }
 
  virtual Model::PutAutoScalingPolicyOutcome PutAutoScalingPolicy(const Model::PutAutoScalingPolicyRequest& request) const;
 
  template <typename PutAutoScalingPolicyRequestT = Model::PutAutoScalingPolicyRequest>
  Model::PutAutoScalingPolicyOutcomeCallable PutAutoScalingPolicyCallable(const PutAutoScalingPolicyRequestT& request) const {
    return SubmitCallable(&EMRClient::PutAutoScalingPolicy, request);
  }
 
  template <typename PutAutoScalingPolicyRequestT = Model::PutAutoScalingPolicyRequest>
  void PutAutoScalingPolicyAsync(const PutAutoScalingPolicyRequestT& request, const PutAutoScalingPolicyResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::PutAutoScalingPolicy, request, handler, context);
  }
 
  virtual Model::PutAutoTerminationPolicyOutcome PutAutoTerminationPolicy(const Model::PutAutoTerminationPolicyRequest& request) const;
 
  template <typename PutAutoTerminationPolicyRequestT = Model::PutAutoTerminationPolicyRequest>
  Model::PutAutoTerminationPolicyOutcomeCallable PutAutoTerminationPolicyCallable(const PutAutoTerminationPolicyRequestT& request) const {
    return SubmitCallable(&EMRClient::PutAutoTerminationPolicy, request);
  }
 
  template <typename PutAutoTerminationPolicyRequestT = Model::PutAutoTerminationPolicyRequest>
  void PutAutoTerminationPolicyAsync(const PutAutoTerminationPolicyRequestT& request,
                                     const PutAutoTerminationPolicyResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::PutAutoTerminationPolicy, request, handler, context);
  }
 
  virtual Model::PutBlockPublicAccessConfigurationOutcome PutBlockPublicAccessConfiguration(
      const Model::PutBlockPublicAccessConfigurationRequest& request) const;
 
  template <typename PutBlockPublicAccessConfigurationRequestT = Model::PutBlockPublicAccessConfigurationRequest>
  Model::PutBlockPublicAccessConfigurationOutcomeCallable PutBlockPublicAccessConfigurationCallable(
      const PutBlockPublicAccessConfigurationRequestT& request) const {
    return SubmitCallable(&EMRClient::PutBlockPublicAccessConfiguration, request);
  }
 
  template <typename PutBlockPublicAccessConfigurationRequestT = Model::PutBlockPublicAccessConfigurationRequest>
  void PutBlockPublicAccessConfigurationAsync(const PutBlockPublicAccessConfigurationRequestT& request,
                                              const PutBlockPublicAccessConfigurationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::PutBlockPublicAccessConfiguration, request, handler, context);
  }
 
  virtual Model::PutManagedScalingPolicyOutcome PutManagedScalingPolicy(const Model::PutManagedScalingPolicyRequest& request) const;
 
  template <typename PutManagedScalingPolicyRequestT = Model::PutManagedScalingPolicyRequest>
  Model::PutManagedScalingPolicyOutcomeCallable PutManagedScalingPolicyCallable(const PutManagedScalingPolicyRequestT& request) const {
    return SubmitCallable(&EMRClient::PutManagedScalingPolicy, request);
  }
 
  template <typename PutManagedScalingPolicyRequestT = Model::PutManagedScalingPolicyRequest>
  void PutManagedScalingPolicyAsync(const PutManagedScalingPolicyRequestT& request,
                                    const PutManagedScalingPolicyResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::PutManagedScalingPolicy, request, handler, context);
  }
 
  virtual Model::RemoveAutoScalingPolicyOutcome RemoveAutoScalingPolicy(const Model::RemoveAutoScalingPolicyRequest& request) const;
 
  template <typename RemoveAutoScalingPolicyRequestT = Model::RemoveAutoScalingPolicyRequest>
  Model::RemoveAutoScalingPolicyOutcomeCallable RemoveAutoScalingPolicyCallable(const RemoveAutoScalingPolicyRequestT& request) const {
    return SubmitCallable(&EMRClient::RemoveAutoScalingPolicy, request);
  }
 
  template <typename RemoveAutoScalingPolicyRequestT = Model::RemoveAutoScalingPolicyRequest>
  void RemoveAutoScalingPolicyAsync(const RemoveAutoScalingPolicyRequestT& request,
                                    const RemoveAutoScalingPolicyResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::RemoveAutoScalingPolicy, request, handler, context);
  }
 
  virtual Model::RemoveAutoTerminationPolicyOutcome RemoveAutoTerminationPolicy(
      const Model::RemoveAutoTerminationPolicyRequest& request) const;
 
  template <typename RemoveAutoTerminationPolicyRequestT = Model::RemoveAutoTerminationPolicyRequest>
  Model::RemoveAutoTerminationPolicyOutcomeCallable RemoveAutoTerminationPolicyCallable(
      const RemoveAutoTerminationPolicyRequestT& request) const {
    return SubmitCallable(&EMRClient::RemoveAutoTerminationPolicy, request);
  }
 
  template <typename RemoveAutoTerminationPolicyRequestT = Model::RemoveAutoTerminationPolicyRequest>
  void RemoveAutoTerminationPolicyAsync(const RemoveAutoTerminationPolicyRequestT& request,
                                        const RemoveAutoTerminationPolicyResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::RemoveAutoTerminationPolicy, request, handler, context);
  }
 
  virtual Model::RemoveManagedScalingPolicyOutcome RemoveManagedScalingPolicy(
      const Model::RemoveManagedScalingPolicyRequest& request) const;
 
  template <typename RemoveManagedScalingPolicyRequestT = Model::RemoveManagedScalingPolicyRequest>
  Model::RemoveManagedScalingPolicyOutcomeCallable RemoveManagedScalingPolicyCallable(
      const RemoveManagedScalingPolicyRequestT& request) const {
    return SubmitCallable(&EMRClient::RemoveManagedScalingPolicy, request);
  }
 
  template <typename RemoveManagedScalingPolicyRequestT = Model::RemoveManagedScalingPolicyRequest>
  void RemoveManagedScalingPolicyAsync(const RemoveManagedScalingPolicyRequestT& request,
                                       const RemoveManagedScalingPolicyResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::RemoveManagedScalingPolicy, request, handler, context);
  }
 
  virtual Model::RemoveTagsOutcome RemoveTags(const Model::RemoveTagsRequest& request) const;
 
  template <typename RemoveTagsRequestT = Model::RemoveTagsRequest>
  Model::RemoveTagsOutcomeCallable RemoveTagsCallable(const RemoveTagsRequestT& request) const {
    return SubmitCallable(&EMRClient::RemoveTags, request);
  }
 
  template <typename RemoveTagsRequestT = Model::RemoveTagsRequest>
  void RemoveTagsAsync(const RemoveTagsRequestT& request, const RemoveTagsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::RemoveTags, request, handler, context);
  }
 
  virtual Model::RunJobFlowOutcome RunJobFlow(const Model::RunJobFlowRequest& request) const;
 
  template <typename RunJobFlowRequestT = Model::RunJobFlowRequest>
  Model::RunJobFlowOutcomeCallable RunJobFlowCallable(const RunJobFlowRequestT& request) const {
    return SubmitCallable(&EMRClient::RunJobFlow, request);
  }
 
  template <typename RunJobFlowRequestT = Model::RunJobFlowRequest>
  void RunJobFlowAsync(const RunJobFlowRequestT& request, const RunJobFlowResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::RunJobFlow, request, handler, context);
  }
 
  virtual Model::SetKeepJobFlowAliveWhenNoStepsOutcome SetKeepJobFlowAliveWhenNoSteps(
      const Model::SetKeepJobFlowAliveWhenNoStepsRequest& request) const;
 
  template <typename SetKeepJobFlowAliveWhenNoStepsRequestT = Model::SetKeepJobFlowAliveWhenNoStepsRequest>
  Model::SetKeepJobFlowAliveWhenNoStepsOutcomeCallable SetKeepJobFlowAliveWhenNoStepsCallable(
      const SetKeepJobFlowAliveWhenNoStepsRequestT& request) const {
    return SubmitCallable(&EMRClient::SetKeepJobFlowAliveWhenNoSteps, request);
  }
 
  template <typename SetKeepJobFlowAliveWhenNoStepsRequestT = Model::SetKeepJobFlowAliveWhenNoStepsRequest>
  void SetKeepJobFlowAliveWhenNoStepsAsync(const SetKeepJobFlowAliveWhenNoStepsRequestT& request,
                                           const SetKeepJobFlowAliveWhenNoStepsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::SetKeepJobFlowAliveWhenNoSteps, request, handler, context);
  }
 
  virtual Model::SetTerminationProtectionOutcome SetTerminationProtection(const Model::SetTerminationProtectionRequest& request) const;
 
  template <typename SetTerminationProtectionRequestT = Model::SetTerminationProtectionRequest>
  Model::SetTerminationProtectionOutcomeCallable SetTerminationProtectionCallable(const SetTerminationProtectionRequestT& request) const {
    return SubmitCallable(&EMRClient::SetTerminationProtection, request);
  }
 
  template <typename SetTerminationProtectionRequestT = Model::SetTerminationProtectionRequest>
  void SetTerminationProtectionAsync(const SetTerminationProtectionRequestT& request,
                                     const SetTerminationProtectionResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::SetTerminationProtection, request, handler, context);
  }
 
  virtual Model::SetUnhealthyNodeReplacementOutcome SetUnhealthyNodeReplacement(
      const Model::SetUnhealthyNodeReplacementRequest& request) const;
 
  template <typename SetUnhealthyNodeReplacementRequestT = Model::SetUnhealthyNodeReplacementRequest>
  Model::SetUnhealthyNodeReplacementOutcomeCallable SetUnhealthyNodeReplacementCallable(
      const SetUnhealthyNodeReplacementRequestT& request) const {
    return SubmitCallable(&EMRClient::SetUnhealthyNodeReplacement, request);
  }
 
  template <typename SetUnhealthyNodeReplacementRequestT = Model::SetUnhealthyNodeReplacementRequest>
  void SetUnhealthyNodeReplacementAsync(const SetUnhealthyNodeReplacementRequestT& request,
                                        const SetUnhealthyNodeReplacementResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::SetUnhealthyNodeReplacement, request, handler, context);
  }
 
  virtual Model::SetVisibleToAllUsersOutcome SetVisibleToAllUsers(const Model::SetVisibleToAllUsersRequest& request) const;
 
  template <typename SetVisibleToAllUsersRequestT = Model::SetVisibleToAllUsersRequest>
  Model::SetVisibleToAllUsersOutcomeCallable SetVisibleToAllUsersCallable(const SetVisibleToAllUsersRequestT& request) const {
    return SubmitCallable(&EMRClient::SetVisibleToAllUsers, request);
  }
 
  template <typename SetVisibleToAllUsersRequestT = Model::SetVisibleToAllUsersRequest>
  void SetVisibleToAllUsersAsync(const SetVisibleToAllUsersRequestT& request, const SetVisibleToAllUsersResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::SetVisibleToAllUsers, request, handler, context);
  }
 
  virtual Model::StartNotebookExecutionOutcome StartNotebookExecution(const Model::StartNotebookExecutionRequest& request) const;
 
  template <typename StartNotebookExecutionRequestT = Model::StartNotebookExecutionRequest>
  Model::StartNotebookExecutionOutcomeCallable StartNotebookExecutionCallable(const StartNotebookExecutionRequestT& request) const {
    return SubmitCallable(&EMRClient::StartNotebookExecution, request);
  }
 
  template <typename StartNotebookExecutionRequestT = Model::StartNotebookExecutionRequest>
  void StartNotebookExecutionAsync(const StartNotebookExecutionRequestT& request,
                                   const StartNotebookExecutionResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::StartNotebookExecution, request, handler, context);
  }
 
  virtual Model::StartSessionOutcome StartSession(const Model::StartSessionRequest& request) const;
 
  template <typename StartSessionRequestT = Model::StartSessionRequest>
  Model::StartSessionOutcomeCallable StartSessionCallable(const StartSessionRequestT& request) const {
    return SubmitCallable(&EMRClient::StartSession, request);
  }
 
  template <typename StartSessionRequestT = Model::StartSessionRequest>
  void StartSessionAsync(const StartSessionRequestT& request, const StartSessionResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::StartSession, request, handler, context);
  }
 
  virtual Model::StopNotebookExecutionOutcome StopNotebookExecution(const Model::StopNotebookExecutionRequest& request) const;
 
  template <typename StopNotebookExecutionRequestT = Model::StopNotebookExecutionRequest>
  Model::StopNotebookExecutionOutcomeCallable StopNotebookExecutionCallable(const StopNotebookExecutionRequestT& request) const {
    return SubmitCallable(&EMRClient::StopNotebookExecution, request);
  }
 
  template <typename StopNotebookExecutionRequestT = Model::StopNotebookExecutionRequest>
  void StopNotebookExecutionAsync(const StopNotebookExecutionRequestT& request, const StopNotebookExecutionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::StopNotebookExecution, request, handler, context);
  }
 
  virtual Model::TerminateJobFlowsOutcome TerminateJobFlows(const Model::TerminateJobFlowsRequest& request) const;
 
  template <typename TerminateJobFlowsRequestT = Model::TerminateJobFlowsRequest>
  Model::TerminateJobFlowsOutcomeCallable TerminateJobFlowsCallable(const TerminateJobFlowsRequestT& request) const {
    return SubmitCallable(&EMRClient::TerminateJobFlows, request);
  }
 
  template <typename TerminateJobFlowsRequestT = Model::TerminateJobFlowsRequest>
  void TerminateJobFlowsAsync(const TerminateJobFlowsRequestT& request, const TerminateJobFlowsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::TerminateJobFlows, request, handler, context);
  }
 
  virtual Model::TerminateSessionOutcome TerminateSession(const Model::TerminateSessionRequest& request) const;
 
  template <typename TerminateSessionRequestT = Model::TerminateSessionRequest>
  Model::TerminateSessionOutcomeCallable TerminateSessionCallable(const TerminateSessionRequestT& request) const {
    return SubmitCallable(&EMRClient::TerminateSession, request);
  }
 
  template <typename TerminateSessionRequestT = Model::TerminateSessionRequest>
  void TerminateSessionAsync(const TerminateSessionRequestT& request, const TerminateSessionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::TerminateSession, request, handler, context);
  }
 
  virtual Model::UpdateStudioOutcome UpdateStudio(const Model::UpdateStudioRequest& request) const;
 
  template <typename UpdateStudioRequestT = Model::UpdateStudioRequest>
  Model::UpdateStudioOutcomeCallable UpdateStudioCallable(const UpdateStudioRequestT& request) const {
    return SubmitCallable(&EMRClient::UpdateStudio, request);
  }
 
  template <typename UpdateStudioRequestT = Model::UpdateStudioRequest>
  void UpdateStudioAsync(const UpdateStudioRequestT& request, const UpdateStudioResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::UpdateStudio, request, handler, context);
  }
 
  virtual Model::UpdateStudioSessionMappingOutcome UpdateStudioSessionMapping(
      const Model::UpdateStudioSessionMappingRequest& request) const;
 
  template <typename UpdateStudioSessionMappingRequestT = Model::UpdateStudioSessionMappingRequest>
  Model::UpdateStudioSessionMappingOutcomeCallable UpdateStudioSessionMappingCallable(
      const UpdateStudioSessionMappingRequestT& request) const {
    return SubmitCallable(&EMRClient::UpdateStudioSessionMapping, request);
  }
 
  template <typename UpdateStudioSessionMappingRequestT = Model::UpdateStudioSessionMappingRequest>
  void UpdateStudioSessionMappingAsync(const UpdateStudioSessionMappingRequestT& request,
                                       const UpdateStudioSessionMappingResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EMRClient::UpdateStudioSessionMapping, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<EMREndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<EMRClient>;
  void init(const EMRClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, EMRError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  EMRClientConfiguration m_clientConfiguration;
  std::shared_ptr<EMREndpointProviderBase> m_endpointProvider;
};
 
}  // namespace EMR
}  // namespace Aws