EMRClient.h

 
#pragma once
#include <aws/elasticmapreduce/EMR_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/elasticmapreduce/EMRServiceClientModel.h>
 
namespace Aws
{
namespace EMR
{
  class AWS_EMR_API EMRClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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::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::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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<EMREndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<EMRClient>;
      void init(const EMRClientConfiguration& clientConfiguration);
 
      EMRClientConfiguration m_clientConfiguration;
      std::shared_ptr<EMREndpointProviderBase> m_endpointProvider;
  };
 
} // namespace EMR
} // namespace Aws