ComprehendClient.h

 
#pragma once
#include <aws/comprehend/Comprehend_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/comprehend/ComprehendServiceClientModel.h>
 
namespace Aws
{
namespace Comprehend
{
  class AWS_COMPREHEND_API ComprehendClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<ComprehendClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef ComprehendClientConfiguration ClientConfigurationType;
      typedef ComprehendEndpointProvider EndpointProviderType;
 
        ComprehendClient(const Aws::Comprehend::ComprehendClientConfiguration& clientConfiguration = Aws::Comprehend::ComprehendClientConfiguration(),
                         std::shared_ptr<ComprehendEndpointProviderBase> endpointProvider = nullptr);
 
        ComprehendClient(const Aws::Auth::AWSCredentials& credentials,
                         std::shared_ptr<ComprehendEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::Comprehend::ComprehendClientConfiguration& clientConfiguration = Aws::Comprehend::ComprehendClientConfiguration());
 
        ComprehendClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         std::shared_ptr<ComprehendEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::Comprehend::ComprehendClientConfiguration& clientConfiguration = Aws::Comprehend::ComprehendClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        ComprehendClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ComprehendClient(const Aws::Auth::AWSCredentials& credentials,
                         const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ComprehendClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~ComprehendClient();
 
        virtual Model::BatchDetectDominantLanguageOutcome BatchDetectDominantLanguage(const Model::BatchDetectDominantLanguageRequest& request) const;
 
        template<typename BatchDetectDominantLanguageRequestT = Model::BatchDetectDominantLanguageRequest>
        Model::BatchDetectDominantLanguageOutcomeCallable BatchDetectDominantLanguageCallable(const BatchDetectDominantLanguageRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::BatchDetectDominantLanguage, request);
        }
 
        template<typename BatchDetectDominantLanguageRequestT = Model::BatchDetectDominantLanguageRequest>
        void BatchDetectDominantLanguageAsync(const BatchDetectDominantLanguageRequestT& request, const BatchDetectDominantLanguageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::BatchDetectDominantLanguage, request, handler, context);
        }
 
        virtual Model::BatchDetectEntitiesOutcome BatchDetectEntities(const Model::BatchDetectEntitiesRequest& request) const;
 
        template<typename BatchDetectEntitiesRequestT = Model::BatchDetectEntitiesRequest>
        Model::BatchDetectEntitiesOutcomeCallable BatchDetectEntitiesCallable(const BatchDetectEntitiesRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::BatchDetectEntities, request);
        }
 
        template<typename BatchDetectEntitiesRequestT = Model::BatchDetectEntitiesRequest>
        void BatchDetectEntitiesAsync(const BatchDetectEntitiesRequestT& request, const BatchDetectEntitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::BatchDetectEntities, request, handler, context);
        }
 
        virtual Model::BatchDetectKeyPhrasesOutcome BatchDetectKeyPhrases(const Model::BatchDetectKeyPhrasesRequest& request) const;
 
        template<typename BatchDetectKeyPhrasesRequestT = Model::BatchDetectKeyPhrasesRequest>
        Model::BatchDetectKeyPhrasesOutcomeCallable BatchDetectKeyPhrasesCallable(const BatchDetectKeyPhrasesRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::BatchDetectKeyPhrases, request);
        }
 
        template<typename BatchDetectKeyPhrasesRequestT = Model::BatchDetectKeyPhrasesRequest>
        void BatchDetectKeyPhrasesAsync(const BatchDetectKeyPhrasesRequestT& request, const BatchDetectKeyPhrasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::BatchDetectKeyPhrases, request, handler, context);
        }
 
        virtual Model::BatchDetectSentimentOutcome BatchDetectSentiment(const Model::BatchDetectSentimentRequest& request) const;
 
        template<typename BatchDetectSentimentRequestT = Model::BatchDetectSentimentRequest>
        Model::BatchDetectSentimentOutcomeCallable BatchDetectSentimentCallable(const BatchDetectSentimentRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::BatchDetectSentiment, request);
        }
 
        template<typename BatchDetectSentimentRequestT = Model::BatchDetectSentimentRequest>
        void BatchDetectSentimentAsync(const BatchDetectSentimentRequestT& request, const BatchDetectSentimentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::BatchDetectSentiment, request, handler, context);
        }
 
        virtual Model::BatchDetectSyntaxOutcome BatchDetectSyntax(const Model::BatchDetectSyntaxRequest& request) const;
 
        template<typename BatchDetectSyntaxRequestT = Model::BatchDetectSyntaxRequest>
        Model::BatchDetectSyntaxOutcomeCallable BatchDetectSyntaxCallable(const BatchDetectSyntaxRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::BatchDetectSyntax, request);
        }
 
        template<typename BatchDetectSyntaxRequestT = Model::BatchDetectSyntaxRequest>
        void BatchDetectSyntaxAsync(const BatchDetectSyntaxRequestT& request, const BatchDetectSyntaxResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::BatchDetectSyntax, request, handler, context);
        }
 
        virtual Model::BatchDetectTargetedSentimentOutcome BatchDetectTargetedSentiment(const Model::BatchDetectTargetedSentimentRequest& request) const;
 
        template<typename BatchDetectTargetedSentimentRequestT = Model::BatchDetectTargetedSentimentRequest>
        Model::BatchDetectTargetedSentimentOutcomeCallable BatchDetectTargetedSentimentCallable(const BatchDetectTargetedSentimentRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::BatchDetectTargetedSentiment, request);
        }
 
        template<typename BatchDetectTargetedSentimentRequestT = Model::BatchDetectTargetedSentimentRequest>
        void BatchDetectTargetedSentimentAsync(const BatchDetectTargetedSentimentRequestT& request, const BatchDetectTargetedSentimentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::BatchDetectTargetedSentiment, request, handler, context);
        }
 
        virtual Model::ClassifyDocumentOutcome ClassifyDocument(const Model::ClassifyDocumentRequest& request) const;
 
        template<typename ClassifyDocumentRequestT = Model::ClassifyDocumentRequest>
        Model::ClassifyDocumentOutcomeCallable ClassifyDocumentCallable(const ClassifyDocumentRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::ClassifyDocument, request);
        }
 
        template<typename ClassifyDocumentRequestT = Model::ClassifyDocumentRequest>
        void ClassifyDocumentAsync(const ClassifyDocumentRequestT& request, const ClassifyDocumentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::ClassifyDocument, request, handler, context);
        }
 
        virtual Model::ContainsPiiEntitiesOutcome ContainsPiiEntities(const Model::ContainsPiiEntitiesRequest& request) const;
 
        template<typename ContainsPiiEntitiesRequestT = Model::ContainsPiiEntitiesRequest>
        Model::ContainsPiiEntitiesOutcomeCallable ContainsPiiEntitiesCallable(const ContainsPiiEntitiesRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::ContainsPiiEntities, request);
        }
 
        template<typename ContainsPiiEntitiesRequestT = Model::ContainsPiiEntitiesRequest>
        void ContainsPiiEntitiesAsync(const ContainsPiiEntitiesRequestT& request, const ContainsPiiEntitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::ContainsPiiEntities, request, handler, context);
        }
 
        virtual Model::CreateDatasetOutcome CreateDataset(const Model::CreateDatasetRequest& request) const;
 
        template<typename CreateDatasetRequestT = Model::CreateDatasetRequest>
        Model::CreateDatasetOutcomeCallable CreateDatasetCallable(const CreateDatasetRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::CreateDataset, request);
        }
 
        template<typename CreateDatasetRequestT = Model::CreateDatasetRequest>
        void CreateDatasetAsync(const CreateDatasetRequestT& request, const CreateDatasetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::CreateDataset, request, handler, context);
        }
 
        virtual Model::CreateDocumentClassifierOutcome CreateDocumentClassifier(const Model::CreateDocumentClassifierRequest& request) const;
 
        template<typename CreateDocumentClassifierRequestT = Model::CreateDocumentClassifierRequest>
        Model::CreateDocumentClassifierOutcomeCallable CreateDocumentClassifierCallable(const CreateDocumentClassifierRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::CreateDocumentClassifier, request);
        }
 
        template<typename CreateDocumentClassifierRequestT = Model::CreateDocumentClassifierRequest>
        void CreateDocumentClassifierAsync(const CreateDocumentClassifierRequestT& request, const CreateDocumentClassifierResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::CreateDocumentClassifier, request, handler, context);
        }
 
        virtual Model::CreateEndpointOutcome CreateEndpoint(const Model::CreateEndpointRequest& request) const;
 
        template<typename CreateEndpointRequestT = Model::CreateEndpointRequest>
        Model::CreateEndpointOutcomeCallable CreateEndpointCallable(const CreateEndpointRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::CreateEndpoint, request);
        }
 
        template<typename CreateEndpointRequestT = Model::CreateEndpointRequest>
        void CreateEndpointAsync(const CreateEndpointRequestT& request, const CreateEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::CreateEndpoint, request, handler, context);
        }
 
        virtual Model::CreateEntityRecognizerOutcome CreateEntityRecognizer(const Model::CreateEntityRecognizerRequest& request) const;
 
        template<typename CreateEntityRecognizerRequestT = Model::CreateEntityRecognizerRequest>
        Model::CreateEntityRecognizerOutcomeCallable CreateEntityRecognizerCallable(const CreateEntityRecognizerRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::CreateEntityRecognizer, request);
        }
 
        template<typename CreateEntityRecognizerRequestT = Model::CreateEntityRecognizerRequest>
        void CreateEntityRecognizerAsync(const CreateEntityRecognizerRequestT& request, const CreateEntityRecognizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::CreateEntityRecognizer, request, handler, context);
        }
 
        virtual Model::CreateFlywheelOutcome CreateFlywheel(const Model::CreateFlywheelRequest& request) const;
 
        template<typename CreateFlywheelRequestT = Model::CreateFlywheelRequest>
        Model::CreateFlywheelOutcomeCallable CreateFlywheelCallable(const CreateFlywheelRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::CreateFlywheel, request);
        }
 
        template<typename CreateFlywheelRequestT = Model::CreateFlywheelRequest>
        void CreateFlywheelAsync(const CreateFlywheelRequestT& request, const CreateFlywheelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::CreateFlywheel, request, handler, context);
        }
 
        virtual Model::DeleteDocumentClassifierOutcome DeleteDocumentClassifier(const Model::DeleteDocumentClassifierRequest& request) const;
 
        template<typename DeleteDocumentClassifierRequestT = Model::DeleteDocumentClassifierRequest>
        Model::DeleteDocumentClassifierOutcomeCallable DeleteDocumentClassifierCallable(const DeleteDocumentClassifierRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::DeleteDocumentClassifier, request);
        }
 
        template<typename DeleteDocumentClassifierRequestT = Model::DeleteDocumentClassifierRequest>
        void DeleteDocumentClassifierAsync(const DeleteDocumentClassifierRequestT& request, const DeleteDocumentClassifierResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::DeleteDocumentClassifier, request, handler, context);
        }
 
        virtual Model::DeleteEndpointOutcome DeleteEndpoint(const Model::DeleteEndpointRequest& request) const;
 
        template<typename DeleteEndpointRequestT = Model::DeleteEndpointRequest>
        Model::DeleteEndpointOutcomeCallable DeleteEndpointCallable(const DeleteEndpointRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::DeleteEndpoint, request);
        }
 
        template<typename DeleteEndpointRequestT = Model::DeleteEndpointRequest>
        void DeleteEndpointAsync(const DeleteEndpointRequestT& request, const DeleteEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::DeleteEndpoint, request, handler, context);
        }
 
        virtual Model::DeleteEntityRecognizerOutcome DeleteEntityRecognizer(const Model::DeleteEntityRecognizerRequest& request) const;
 
        template<typename DeleteEntityRecognizerRequestT = Model::DeleteEntityRecognizerRequest>
        Model::DeleteEntityRecognizerOutcomeCallable DeleteEntityRecognizerCallable(const DeleteEntityRecognizerRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::DeleteEntityRecognizer, request);
        }
 
        template<typename DeleteEntityRecognizerRequestT = Model::DeleteEntityRecognizerRequest>
        void DeleteEntityRecognizerAsync(const DeleteEntityRecognizerRequestT& request, const DeleteEntityRecognizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::DeleteEntityRecognizer, request, handler, context);
        }
 
        virtual Model::DeleteFlywheelOutcome DeleteFlywheel(const Model::DeleteFlywheelRequest& request) const;
 
        template<typename DeleteFlywheelRequestT = Model::DeleteFlywheelRequest>
        Model::DeleteFlywheelOutcomeCallable DeleteFlywheelCallable(const DeleteFlywheelRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::DeleteFlywheel, request);
        }
 
        template<typename DeleteFlywheelRequestT = Model::DeleteFlywheelRequest>
        void DeleteFlywheelAsync(const DeleteFlywheelRequestT& request, const DeleteFlywheelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::DeleteFlywheel, request, handler, context);
        }
 
        virtual Model::DeleteResourcePolicyOutcome DeleteResourcePolicy(const Model::DeleteResourcePolicyRequest& request) const;
 
        template<typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
        Model::DeleteResourcePolicyOutcomeCallable DeleteResourcePolicyCallable(const DeleteResourcePolicyRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::DeleteResourcePolicy, request);
        }
 
        template<typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
        void DeleteResourcePolicyAsync(const DeleteResourcePolicyRequestT& request, const DeleteResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::DeleteResourcePolicy, request, handler, context);
        }
 
        virtual Model::DescribeDatasetOutcome DescribeDataset(const Model::DescribeDatasetRequest& request) const;
 
        template<typename DescribeDatasetRequestT = Model::DescribeDatasetRequest>
        Model::DescribeDatasetOutcomeCallable DescribeDatasetCallable(const DescribeDatasetRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::DescribeDataset, request);
        }
 
        template<typename DescribeDatasetRequestT = Model::DescribeDatasetRequest>
        void DescribeDatasetAsync(const DescribeDatasetRequestT& request, const DescribeDatasetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::DescribeDataset, request, handler, context);
        }
 
        virtual Model::DescribeDocumentClassificationJobOutcome DescribeDocumentClassificationJob(const Model::DescribeDocumentClassificationJobRequest& request) const;
 
        template<typename DescribeDocumentClassificationJobRequestT = Model::DescribeDocumentClassificationJobRequest>
        Model::DescribeDocumentClassificationJobOutcomeCallable DescribeDocumentClassificationJobCallable(const DescribeDocumentClassificationJobRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::DescribeDocumentClassificationJob, request);
        }
 
        template<typename DescribeDocumentClassificationJobRequestT = Model::DescribeDocumentClassificationJobRequest>
        void DescribeDocumentClassificationJobAsync(const DescribeDocumentClassificationJobRequestT& request, const DescribeDocumentClassificationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::DescribeDocumentClassificationJob, request, handler, context);
        }
 
        virtual Model::DescribeDocumentClassifierOutcome DescribeDocumentClassifier(const Model::DescribeDocumentClassifierRequest& request) const;
 
        template<typename DescribeDocumentClassifierRequestT = Model::DescribeDocumentClassifierRequest>
        Model::DescribeDocumentClassifierOutcomeCallable DescribeDocumentClassifierCallable(const DescribeDocumentClassifierRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::DescribeDocumentClassifier, request);
        }
 
        template<typename DescribeDocumentClassifierRequestT = Model::DescribeDocumentClassifierRequest>
        void DescribeDocumentClassifierAsync(const DescribeDocumentClassifierRequestT& request, const DescribeDocumentClassifierResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::DescribeDocumentClassifier, request, handler, context);
        }
 
        virtual Model::DescribeDominantLanguageDetectionJobOutcome DescribeDominantLanguageDetectionJob(const Model::DescribeDominantLanguageDetectionJobRequest& request) const;
 
        template<typename DescribeDominantLanguageDetectionJobRequestT = Model::DescribeDominantLanguageDetectionJobRequest>
        Model::DescribeDominantLanguageDetectionJobOutcomeCallable DescribeDominantLanguageDetectionJobCallable(const DescribeDominantLanguageDetectionJobRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::DescribeDominantLanguageDetectionJob, request);
        }
 
        template<typename DescribeDominantLanguageDetectionJobRequestT = Model::DescribeDominantLanguageDetectionJobRequest>
        void DescribeDominantLanguageDetectionJobAsync(const DescribeDominantLanguageDetectionJobRequestT& request, const DescribeDominantLanguageDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::DescribeDominantLanguageDetectionJob, request, handler, context);
        }
 
        virtual Model::DescribeEndpointOutcome DescribeEndpoint(const Model::DescribeEndpointRequest& request) const;
 
        template<typename DescribeEndpointRequestT = Model::DescribeEndpointRequest>
        Model::DescribeEndpointOutcomeCallable DescribeEndpointCallable(const DescribeEndpointRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::DescribeEndpoint, request);
        }
 
        template<typename DescribeEndpointRequestT = Model::DescribeEndpointRequest>
        void DescribeEndpointAsync(const DescribeEndpointRequestT& request, const DescribeEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::DescribeEndpoint, request, handler, context);
        }
 
        virtual Model::DescribeEntitiesDetectionJobOutcome DescribeEntitiesDetectionJob(const Model::DescribeEntitiesDetectionJobRequest& request) const;
 
        template<typename DescribeEntitiesDetectionJobRequestT = Model::DescribeEntitiesDetectionJobRequest>
        Model::DescribeEntitiesDetectionJobOutcomeCallable DescribeEntitiesDetectionJobCallable(const DescribeEntitiesDetectionJobRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::DescribeEntitiesDetectionJob, request);
        }
 
        template<typename DescribeEntitiesDetectionJobRequestT = Model::DescribeEntitiesDetectionJobRequest>
        void DescribeEntitiesDetectionJobAsync(const DescribeEntitiesDetectionJobRequestT& request, const DescribeEntitiesDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::DescribeEntitiesDetectionJob, request, handler, context);
        }
 
        virtual Model::DescribeEntityRecognizerOutcome DescribeEntityRecognizer(const Model::DescribeEntityRecognizerRequest& request) const;
 
        template<typename DescribeEntityRecognizerRequestT = Model::DescribeEntityRecognizerRequest>
        Model::DescribeEntityRecognizerOutcomeCallable DescribeEntityRecognizerCallable(const DescribeEntityRecognizerRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::DescribeEntityRecognizer, request);
        }
 
        template<typename DescribeEntityRecognizerRequestT = Model::DescribeEntityRecognizerRequest>
        void DescribeEntityRecognizerAsync(const DescribeEntityRecognizerRequestT& request, const DescribeEntityRecognizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::DescribeEntityRecognizer, request, handler, context);
        }
 
        virtual Model::DescribeEventsDetectionJobOutcome DescribeEventsDetectionJob(const Model::DescribeEventsDetectionJobRequest& request) const;
 
        template<typename DescribeEventsDetectionJobRequestT = Model::DescribeEventsDetectionJobRequest>
        Model::DescribeEventsDetectionJobOutcomeCallable DescribeEventsDetectionJobCallable(const DescribeEventsDetectionJobRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::DescribeEventsDetectionJob, request);
        }
 
        template<typename DescribeEventsDetectionJobRequestT = Model::DescribeEventsDetectionJobRequest>
        void DescribeEventsDetectionJobAsync(const DescribeEventsDetectionJobRequestT& request, const DescribeEventsDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::DescribeEventsDetectionJob, request, handler, context);
        }
 
        virtual Model::DescribeFlywheelOutcome DescribeFlywheel(const Model::DescribeFlywheelRequest& request) const;
 
        template<typename DescribeFlywheelRequestT = Model::DescribeFlywheelRequest>
        Model::DescribeFlywheelOutcomeCallable DescribeFlywheelCallable(const DescribeFlywheelRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::DescribeFlywheel, request);
        }
 
        template<typename DescribeFlywheelRequestT = Model::DescribeFlywheelRequest>
        void DescribeFlywheelAsync(const DescribeFlywheelRequestT& request, const DescribeFlywheelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::DescribeFlywheel, request, handler, context);
        }
 
        virtual Model::DescribeFlywheelIterationOutcome DescribeFlywheelIteration(const Model::DescribeFlywheelIterationRequest& request) const;
 
        template<typename DescribeFlywheelIterationRequestT = Model::DescribeFlywheelIterationRequest>
        Model::DescribeFlywheelIterationOutcomeCallable DescribeFlywheelIterationCallable(const DescribeFlywheelIterationRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::DescribeFlywheelIteration, request);
        }
 
        template<typename DescribeFlywheelIterationRequestT = Model::DescribeFlywheelIterationRequest>
        void DescribeFlywheelIterationAsync(const DescribeFlywheelIterationRequestT& request, const DescribeFlywheelIterationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::DescribeFlywheelIteration, request, handler, context);
        }
 
        virtual Model::DescribeKeyPhrasesDetectionJobOutcome DescribeKeyPhrasesDetectionJob(const Model::DescribeKeyPhrasesDetectionJobRequest& request) const;
 
        template<typename DescribeKeyPhrasesDetectionJobRequestT = Model::DescribeKeyPhrasesDetectionJobRequest>
        Model::DescribeKeyPhrasesDetectionJobOutcomeCallable DescribeKeyPhrasesDetectionJobCallable(const DescribeKeyPhrasesDetectionJobRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::DescribeKeyPhrasesDetectionJob, request);
        }
 
        template<typename DescribeKeyPhrasesDetectionJobRequestT = Model::DescribeKeyPhrasesDetectionJobRequest>
        void DescribeKeyPhrasesDetectionJobAsync(const DescribeKeyPhrasesDetectionJobRequestT& request, const DescribeKeyPhrasesDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::DescribeKeyPhrasesDetectionJob, request, handler, context);
        }
 
        virtual Model::DescribePiiEntitiesDetectionJobOutcome DescribePiiEntitiesDetectionJob(const Model::DescribePiiEntitiesDetectionJobRequest& request) const;
 
        template<typename DescribePiiEntitiesDetectionJobRequestT = Model::DescribePiiEntitiesDetectionJobRequest>
        Model::DescribePiiEntitiesDetectionJobOutcomeCallable DescribePiiEntitiesDetectionJobCallable(const DescribePiiEntitiesDetectionJobRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::DescribePiiEntitiesDetectionJob, request);
        }
 
        template<typename DescribePiiEntitiesDetectionJobRequestT = Model::DescribePiiEntitiesDetectionJobRequest>
        void DescribePiiEntitiesDetectionJobAsync(const DescribePiiEntitiesDetectionJobRequestT& request, const DescribePiiEntitiesDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::DescribePiiEntitiesDetectionJob, request, handler, context);
        }
 
        virtual Model::DescribeResourcePolicyOutcome DescribeResourcePolicy(const Model::DescribeResourcePolicyRequest& request) const;
 
        template<typename DescribeResourcePolicyRequestT = Model::DescribeResourcePolicyRequest>
        Model::DescribeResourcePolicyOutcomeCallable DescribeResourcePolicyCallable(const DescribeResourcePolicyRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::DescribeResourcePolicy, request);
        }
 
        template<typename DescribeResourcePolicyRequestT = Model::DescribeResourcePolicyRequest>
        void DescribeResourcePolicyAsync(const DescribeResourcePolicyRequestT& request, const DescribeResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::DescribeResourcePolicy, request, handler, context);
        }
 
        virtual Model::DescribeSentimentDetectionJobOutcome DescribeSentimentDetectionJob(const Model::DescribeSentimentDetectionJobRequest& request) const;
 
        template<typename DescribeSentimentDetectionJobRequestT = Model::DescribeSentimentDetectionJobRequest>
        Model::DescribeSentimentDetectionJobOutcomeCallable DescribeSentimentDetectionJobCallable(const DescribeSentimentDetectionJobRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::DescribeSentimentDetectionJob, request);
        }
 
        template<typename DescribeSentimentDetectionJobRequestT = Model::DescribeSentimentDetectionJobRequest>
        void DescribeSentimentDetectionJobAsync(const DescribeSentimentDetectionJobRequestT& request, const DescribeSentimentDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::DescribeSentimentDetectionJob, request, handler, context);
        }
 
        virtual Model::DescribeTargetedSentimentDetectionJobOutcome DescribeTargetedSentimentDetectionJob(const Model::DescribeTargetedSentimentDetectionJobRequest& request) const;
 
        template<typename DescribeTargetedSentimentDetectionJobRequestT = Model::DescribeTargetedSentimentDetectionJobRequest>
        Model::DescribeTargetedSentimentDetectionJobOutcomeCallable DescribeTargetedSentimentDetectionJobCallable(const DescribeTargetedSentimentDetectionJobRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::DescribeTargetedSentimentDetectionJob, request);
        }
 
        template<typename DescribeTargetedSentimentDetectionJobRequestT = Model::DescribeTargetedSentimentDetectionJobRequest>
        void DescribeTargetedSentimentDetectionJobAsync(const DescribeTargetedSentimentDetectionJobRequestT& request, const DescribeTargetedSentimentDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::DescribeTargetedSentimentDetectionJob, request, handler, context);
        }
 
        virtual Model::DescribeTopicsDetectionJobOutcome DescribeTopicsDetectionJob(const Model::DescribeTopicsDetectionJobRequest& request) const;
 
        template<typename DescribeTopicsDetectionJobRequestT = Model::DescribeTopicsDetectionJobRequest>
        Model::DescribeTopicsDetectionJobOutcomeCallable DescribeTopicsDetectionJobCallable(const DescribeTopicsDetectionJobRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::DescribeTopicsDetectionJob, request);
        }
 
        template<typename DescribeTopicsDetectionJobRequestT = Model::DescribeTopicsDetectionJobRequest>
        void DescribeTopicsDetectionJobAsync(const DescribeTopicsDetectionJobRequestT& request, const DescribeTopicsDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::DescribeTopicsDetectionJob, request, handler, context);
        }
 
        virtual Model::DetectDominantLanguageOutcome DetectDominantLanguage(const Model::DetectDominantLanguageRequest& request) const;
 
        template<typename DetectDominantLanguageRequestT = Model::DetectDominantLanguageRequest>
        Model::DetectDominantLanguageOutcomeCallable DetectDominantLanguageCallable(const DetectDominantLanguageRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::DetectDominantLanguage, request);
        }
 
        template<typename DetectDominantLanguageRequestT = Model::DetectDominantLanguageRequest>
        void DetectDominantLanguageAsync(const DetectDominantLanguageRequestT& request, const DetectDominantLanguageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::DetectDominantLanguage, request, handler, context);
        }
 
        virtual Model::DetectEntitiesOutcome DetectEntities(const Model::DetectEntitiesRequest& request = {}) const;
 
        template<typename DetectEntitiesRequestT = Model::DetectEntitiesRequest>
        Model::DetectEntitiesOutcomeCallable DetectEntitiesCallable(const DetectEntitiesRequestT& request = {}) const
        {
            return SubmitCallable(&ComprehendClient::DetectEntities, request);
        }
 
        template<typename DetectEntitiesRequestT = Model::DetectEntitiesRequest>
        void DetectEntitiesAsync(const DetectEntitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DetectEntitiesRequestT& request = {}) const
        {
            return SubmitAsync(&ComprehendClient::DetectEntities, request, handler, context);
        }
 
        virtual Model::DetectKeyPhrasesOutcome DetectKeyPhrases(const Model::DetectKeyPhrasesRequest& request) const;
 
        template<typename DetectKeyPhrasesRequestT = Model::DetectKeyPhrasesRequest>
        Model::DetectKeyPhrasesOutcomeCallable DetectKeyPhrasesCallable(const DetectKeyPhrasesRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::DetectKeyPhrases, request);
        }
 
        template<typename DetectKeyPhrasesRequestT = Model::DetectKeyPhrasesRequest>
        void DetectKeyPhrasesAsync(const DetectKeyPhrasesRequestT& request, const DetectKeyPhrasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::DetectKeyPhrases, request, handler, context);
        }
 
        virtual Model::DetectPiiEntitiesOutcome DetectPiiEntities(const Model::DetectPiiEntitiesRequest& request) const;
 
        template<typename DetectPiiEntitiesRequestT = Model::DetectPiiEntitiesRequest>
        Model::DetectPiiEntitiesOutcomeCallable DetectPiiEntitiesCallable(const DetectPiiEntitiesRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::DetectPiiEntities, request);
        }
 
        template<typename DetectPiiEntitiesRequestT = Model::DetectPiiEntitiesRequest>
        void DetectPiiEntitiesAsync(const DetectPiiEntitiesRequestT& request, const DetectPiiEntitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::DetectPiiEntities, request, handler, context);
        }
 
        virtual Model::DetectSentimentOutcome DetectSentiment(const Model::DetectSentimentRequest& request) const;
 
        template<typename DetectSentimentRequestT = Model::DetectSentimentRequest>
        Model::DetectSentimentOutcomeCallable DetectSentimentCallable(const DetectSentimentRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::DetectSentiment, request);
        }
 
        template<typename DetectSentimentRequestT = Model::DetectSentimentRequest>
        void DetectSentimentAsync(const DetectSentimentRequestT& request, const DetectSentimentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::DetectSentiment, request, handler, context);
        }
 
        virtual Model::DetectSyntaxOutcome DetectSyntax(const Model::DetectSyntaxRequest& request) const;
 
        template<typename DetectSyntaxRequestT = Model::DetectSyntaxRequest>
        Model::DetectSyntaxOutcomeCallable DetectSyntaxCallable(const DetectSyntaxRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::DetectSyntax, request);
        }
 
        template<typename DetectSyntaxRequestT = Model::DetectSyntaxRequest>
        void DetectSyntaxAsync(const DetectSyntaxRequestT& request, const DetectSyntaxResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::DetectSyntax, request, handler, context);
        }
 
        virtual Model::DetectTargetedSentimentOutcome DetectTargetedSentiment(const Model::DetectTargetedSentimentRequest& request) const;
 
        template<typename DetectTargetedSentimentRequestT = Model::DetectTargetedSentimentRequest>
        Model::DetectTargetedSentimentOutcomeCallable DetectTargetedSentimentCallable(const DetectTargetedSentimentRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::DetectTargetedSentiment, request);
        }
 
        template<typename DetectTargetedSentimentRequestT = Model::DetectTargetedSentimentRequest>
        void DetectTargetedSentimentAsync(const DetectTargetedSentimentRequestT& request, const DetectTargetedSentimentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::DetectTargetedSentiment, request, handler, context);
        }
 
        virtual Model::DetectToxicContentOutcome DetectToxicContent(const Model::DetectToxicContentRequest& request) const;
 
        template<typename DetectToxicContentRequestT = Model::DetectToxicContentRequest>
        Model::DetectToxicContentOutcomeCallable DetectToxicContentCallable(const DetectToxicContentRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::DetectToxicContent, request);
        }
 
        template<typename DetectToxicContentRequestT = Model::DetectToxicContentRequest>
        void DetectToxicContentAsync(const DetectToxicContentRequestT& request, const DetectToxicContentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::DetectToxicContent, request, handler, context);
        }
 
        virtual Model::ImportModelOutcome ImportModel(const Model::ImportModelRequest& request) const;
 
        template<typename ImportModelRequestT = Model::ImportModelRequest>
        Model::ImportModelOutcomeCallable ImportModelCallable(const ImportModelRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::ImportModel, request);
        }
 
        template<typename ImportModelRequestT = Model::ImportModelRequest>
        void ImportModelAsync(const ImportModelRequestT& request, const ImportModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::ImportModel, request, handler, context);
        }
 
        virtual Model::ListDatasetsOutcome ListDatasets(const Model::ListDatasetsRequest& request = {}) const;
 
        template<typename ListDatasetsRequestT = Model::ListDatasetsRequest>
        Model::ListDatasetsOutcomeCallable ListDatasetsCallable(const ListDatasetsRequestT& request = {}) const
        {
            return SubmitCallable(&ComprehendClient::ListDatasets, request);
        }
 
        template<typename ListDatasetsRequestT = Model::ListDatasetsRequest>
        void ListDatasetsAsync(const ListDatasetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDatasetsRequestT& request = {}) const
        {
            return SubmitAsync(&ComprehendClient::ListDatasets, request, handler, context);
        }
 
        virtual Model::ListDocumentClassificationJobsOutcome ListDocumentClassificationJobs(const Model::ListDocumentClassificationJobsRequest& request = {}) const;
 
        template<typename ListDocumentClassificationJobsRequestT = Model::ListDocumentClassificationJobsRequest>
        Model::ListDocumentClassificationJobsOutcomeCallable ListDocumentClassificationJobsCallable(const ListDocumentClassificationJobsRequestT& request = {}) const
        {
            return SubmitCallable(&ComprehendClient::ListDocumentClassificationJobs, request);
        }
 
        template<typename ListDocumentClassificationJobsRequestT = Model::ListDocumentClassificationJobsRequest>
        void ListDocumentClassificationJobsAsync(const ListDocumentClassificationJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDocumentClassificationJobsRequestT& request = {}) const
        {
            return SubmitAsync(&ComprehendClient::ListDocumentClassificationJobs, request, handler, context);
        }
 
        virtual Model::ListDocumentClassifierSummariesOutcome ListDocumentClassifierSummaries(const Model::ListDocumentClassifierSummariesRequest& request = {}) const;
 
        template<typename ListDocumentClassifierSummariesRequestT = Model::ListDocumentClassifierSummariesRequest>
        Model::ListDocumentClassifierSummariesOutcomeCallable ListDocumentClassifierSummariesCallable(const ListDocumentClassifierSummariesRequestT& request = {}) const
        {
            return SubmitCallable(&ComprehendClient::ListDocumentClassifierSummaries, request);
        }
 
        template<typename ListDocumentClassifierSummariesRequestT = Model::ListDocumentClassifierSummariesRequest>
        void ListDocumentClassifierSummariesAsync(const ListDocumentClassifierSummariesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDocumentClassifierSummariesRequestT& request = {}) const
        {
            return SubmitAsync(&ComprehendClient::ListDocumentClassifierSummaries, request, handler, context);
        }
 
        virtual Model::ListDocumentClassifiersOutcome ListDocumentClassifiers(const Model::ListDocumentClassifiersRequest& request = {}) const;
 
        template<typename ListDocumentClassifiersRequestT = Model::ListDocumentClassifiersRequest>
        Model::ListDocumentClassifiersOutcomeCallable ListDocumentClassifiersCallable(const ListDocumentClassifiersRequestT& request = {}) const
        {
            return SubmitCallable(&ComprehendClient::ListDocumentClassifiers, request);
        }
 
        template<typename ListDocumentClassifiersRequestT = Model::ListDocumentClassifiersRequest>
        void ListDocumentClassifiersAsync(const ListDocumentClassifiersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDocumentClassifiersRequestT& request = {}) const
        {
            return SubmitAsync(&ComprehendClient::ListDocumentClassifiers, request, handler, context);
        }
 
        virtual Model::ListDominantLanguageDetectionJobsOutcome ListDominantLanguageDetectionJobs(const Model::ListDominantLanguageDetectionJobsRequest& request = {}) const;
 
        template<typename ListDominantLanguageDetectionJobsRequestT = Model::ListDominantLanguageDetectionJobsRequest>
        Model::ListDominantLanguageDetectionJobsOutcomeCallable ListDominantLanguageDetectionJobsCallable(const ListDominantLanguageDetectionJobsRequestT& request = {}) const
        {
            return SubmitCallable(&ComprehendClient::ListDominantLanguageDetectionJobs, request);
        }
 
        template<typename ListDominantLanguageDetectionJobsRequestT = Model::ListDominantLanguageDetectionJobsRequest>
        void ListDominantLanguageDetectionJobsAsync(const ListDominantLanguageDetectionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDominantLanguageDetectionJobsRequestT& request = {}) const
        {
            return SubmitAsync(&ComprehendClient::ListDominantLanguageDetectionJobs, request, handler, context);
        }
 
        virtual Model::ListEndpointsOutcome ListEndpoints(const Model::ListEndpointsRequest& request = {}) const;
 
        template<typename ListEndpointsRequestT = Model::ListEndpointsRequest>
        Model::ListEndpointsOutcomeCallable ListEndpointsCallable(const ListEndpointsRequestT& request = {}) const
        {
            return SubmitCallable(&ComprehendClient::ListEndpoints, request);
        }
 
        template<typename ListEndpointsRequestT = Model::ListEndpointsRequest>
        void ListEndpointsAsync(const ListEndpointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListEndpointsRequestT& request = {}) const
        {
            return SubmitAsync(&ComprehendClient::ListEndpoints, request, handler, context);
        }
 
        virtual Model::ListEntitiesDetectionJobsOutcome ListEntitiesDetectionJobs(const Model::ListEntitiesDetectionJobsRequest& request = {}) const;
 
        template<typename ListEntitiesDetectionJobsRequestT = Model::ListEntitiesDetectionJobsRequest>
        Model::ListEntitiesDetectionJobsOutcomeCallable ListEntitiesDetectionJobsCallable(const ListEntitiesDetectionJobsRequestT& request = {}) const
        {
            return SubmitCallable(&ComprehendClient::ListEntitiesDetectionJobs, request);
        }
 
        template<typename ListEntitiesDetectionJobsRequestT = Model::ListEntitiesDetectionJobsRequest>
        void ListEntitiesDetectionJobsAsync(const ListEntitiesDetectionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListEntitiesDetectionJobsRequestT& request = {}) const
        {
            return SubmitAsync(&ComprehendClient::ListEntitiesDetectionJobs, request, handler, context);
        }
 
        virtual Model::ListEntityRecognizerSummariesOutcome ListEntityRecognizerSummaries(const Model::ListEntityRecognizerSummariesRequest& request = {}) const;
 
        template<typename ListEntityRecognizerSummariesRequestT = Model::ListEntityRecognizerSummariesRequest>
        Model::ListEntityRecognizerSummariesOutcomeCallable ListEntityRecognizerSummariesCallable(const ListEntityRecognizerSummariesRequestT& request = {}) const
        {
            return SubmitCallable(&ComprehendClient::ListEntityRecognizerSummaries, request);
        }
 
        template<typename ListEntityRecognizerSummariesRequestT = Model::ListEntityRecognizerSummariesRequest>
        void ListEntityRecognizerSummariesAsync(const ListEntityRecognizerSummariesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListEntityRecognizerSummariesRequestT& request = {}) const
        {
            return SubmitAsync(&ComprehendClient::ListEntityRecognizerSummaries, request, handler, context);
        }
 
        virtual Model::ListEntityRecognizersOutcome ListEntityRecognizers(const Model::ListEntityRecognizersRequest& request = {}) const;
 
        template<typename ListEntityRecognizersRequestT = Model::ListEntityRecognizersRequest>
        Model::ListEntityRecognizersOutcomeCallable ListEntityRecognizersCallable(const ListEntityRecognizersRequestT& request = {}) const
        {
            return SubmitCallable(&ComprehendClient::ListEntityRecognizers, request);
        }
 
        template<typename ListEntityRecognizersRequestT = Model::ListEntityRecognizersRequest>
        void ListEntityRecognizersAsync(const ListEntityRecognizersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListEntityRecognizersRequestT& request = {}) const
        {
            return SubmitAsync(&ComprehendClient::ListEntityRecognizers, request, handler, context);
        }
 
        virtual Model::ListEventsDetectionJobsOutcome ListEventsDetectionJobs(const Model::ListEventsDetectionJobsRequest& request = {}) const;
 
        template<typename ListEventsDetectionJobsRequestT = Model::ListEventsDetectionJobsRequest>
        Model::ListEventsDetectionJobsOutcomeCallable ListEventsDetectionJobsCallable(const ListEventsDetectionJobsRequestT& request = {}) const
        {
            return SubmitCallable(&ComprehendClient::ListEventsDetectionJobs, request);
        }
 
        template<typename ListEventsDetectionJobsRequestT = Model::ListEventsDetectionJobsRequest>
        void ListEventsDetectionJobsAsync(const ListEventsDetectionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListEventsDetectionJobsRequestT& request = {}) const
        {
            return SubmitAsync(&ComprehendClient::ListEventsDetectionJobs, request, handler, context);
        }
 
        virtual Model::ListFlywheelIterationHistoryOutcome ListFlywheelIterationHistory(const Model::ListFlywheelIterationHistoryRequest& request) const;
 
        template<typename ListFlywheelIterationHistoryRequestT = Model::ListFlywheelIterationHistoryRequest>
        Model::ListFlywheelIterationHistoryOutcomeCallable ListFlywheelIterationHistoryCallable(const ListFlywheelIterationHistoryRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::ListFlywheelIterationHistory, request);
        }
 
        template<typename ListFlywheelIterationHistoryRequestT = Model::ListFlywheelIterationHistoryRequest>
        void ListFlywheelIterationHistoryAsync(const ListFlywheelIterationHistoryRequestT& request, const ListFlywheelIterationHistoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::ListFlywheelIterationHistory, request, handler, context);
        }
 
        virtual Model::ListFlywheelsOutcome ListFlywheels(const Model::ListFlywheelsRequest& request = {}) const;
 
        template<typename ListFlywheelsRequestT = Model::ListFlywheelsRequest>
        Model::ListFlywheelsOutcomeCallable ListFlywheelsCallable(const ListFlywheelsRequestT& request = {}) const
        {
            return SubmitCallable(&ComprehendClient::ListFlywheels, request);
        }
 
        template<typename ListFlywheelsRequestT = Model::ListFlywheelsRequest>
        void ListFlywheelsAsync(const ListFlywheelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListFlywheelsRequestT& request = {}) const
        {
            return SubmitAsync(&ComprehendClient::ListFlywheels, request, handler, context);
        }
 
        virtual Model::ListKeyPhrasesDetectionJobsOutcome ListKeyPhrasesDetectionJobs(const Model::ListKeyPhrasesDetectionJobsRequest& request = {}) const;
 
        template<typename ListKeyPhrasesDetectionJobsRequestT = Model::ListKeyPhrasesDetectionJobsRequest>
        Model::ListKeyPhrasesDetectionJobsOutcomeCallable ListKeyPhrasesDetectionJobsCallable(const ListKeyPhrasesDetectionJobsRequestT& request = {}) const
        {
            return SubmitCallable(&ComprehendClient::ListKeyPhrasesDetectionJobs, request);
        }
 
        template<typename ListKeyPhrasesDetectionJobsRequestT = Model::ListKeyPhrasesDetectionJobsRequest>
        void ListKeyPhrasesDetectionJobsAsync(const ListKeyPhrasesDetectionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListKeyPhrasesDetectionJobsRequestT& request = {}) const
        {
            return SubmitAsync(&ComprehendClient::ListKeyPhrasesDetectionJobs, request, handler, context);
        }
 
        virtual Model::ListPiiEntitiesDetectionJobsOutcome ListPiiEntitiesDetectionJobs(const Model::ListPiiEntitiesDetectionJobsRequest& request = {}) const;
 
        template<typename ListPiiEntitiesDetectionJobsRequestT = Model::ListPiiEntitiesDetectionJobsRequest>
        Model::ListPiiEntitiesDetectionJobsOutcomeCallable ListPiiEntitiesDetectionJobsCallable(const ListPiiEntitiesDetectionJobsRequestT& request = {}) const
        {
            return SubmitCallable(&ComprehendClient::ListPiiEntitiesDetectionJobs, request);
        }
 
        template<typename ListPiiEntitiesDetectionJobsRequestT = Model::ListPiiEntitiesDetectionJobsRequest>
        void ListPiiEntitiesDetectionJobsAsync(const ListPiiEntitiesDetectionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPiiEntitiesDetectionJobsRequestT& request = {}) const
        {
            return SubmitAsync(&ComprehendClient::ListPiiEntitiesDetectionJobs, request, handler, context);
        }
 
        virtual Model::ListSentimentDetectionJobsOutcome ListSentimentDetectionJobs(const Model::ListSentimentDetectionJobsRequest& request = {}) const;
 
        template<typename ListSentimentDetectionJobsRequestT = Model::ListSentimentDetectionJobsRequest>
        Model::ListSentimentDetectionJobsOutcomeCallable ListSentimentDetectionJobsCallable(const ListSentimentDetectionJobsRequestT& request = {}) const
        {
            return SubmitCallable(&ComprehendClient::ListSentimentDetectionJobs, request);
        }
 
        template<typename ListSentimentDetectionJobsRequestT = Model::ListSentimentDetectionJobsRequest>
        void ListSentimentDetectionJobsAsync(const ListSentimentDetectionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSentimentDetectionJobsRequestT& request = {}) const
        {
            return SubmitAsync(&ComprehendClient::ListSentimentDetectionJobs, request, handler, context);
        }
 
        virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::ListTagsForResource, request);
        }
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListTargetedSentimentDetectionJobsOutcome ListTargetedSentimentDetectionJobs(const Model::ListTargetedSentimentDetectionJobsRequest& request = {}) const;
 
        template<typename ListTargetedSentimentDetectionJobsRequestT = Model::ListTargetedSentimentDetectionJobsRequest>
        Model::ListTargetedSentimentDetectionJobsOutcomeCallable ListTargetedSentimentDetectionJobsCallable(const ListTargetedSentimentDetectionJobsRequestT& request = {}) const
        {
            return SubmitCallable(&ComprehendClient::ListTargetedSentimentDetectionJobs, request);
        }
 
        template<typename ListTargetedSentimentDetectionJobsRequestT = Model::ListTargetedSentimentDetectionJobsRequest>
        void ListTargetedSentimentDetectionJobsAsync(const ListTargetedSentimentDetectionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTargetedSentimentDetectionJobsRequestT& request = {}) const
        {
            return SubmitAsync(&ComprehendClient::ListTargetedSentimentDetectionJobs, request, handler, context);
        }
 
        virtual Model::ListTopicsDetectionJobsOutcome ListTopicsDetectionJobs(const Model::ListTopicsDetectionJobsRequest& request = {}) const;
 
        template<typename ListTopicsDetectionJobsRequestT = Model::ListTopicsDetectionJobsRequest>
        Model::ListTopicsDetectionJobsOutcomeCallable ListTopicsDetectionJobsCallable(const ListTopicsDetectionJobsRequestT& request = {}) const
        {
            return SubmitCallable(&ComprehendClient::ListTopicsDetectionJobs, request);
        }
 
        template<typename ListTopicsDetectionJobsRequestT = Model::ListTopicsDetectionJobsRequest>
        void ListTopicsDetectionJobsAsync(const ListTopicsDetectionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTopicsDetectionJobsRequestT& request = {}) const
        {
            return SubmitAsync(&ComprehendClient::ListTopicsDetectionJobs, request, handler, context);
        }
 
        virtual Model::PutResourcePolicyOutcome PutResourcePolicy(const Model::PutResourcePolicyRequest& request) const;
 
        template<typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
        Model::PutResourcePolicyOutcomeCallable PutResourcePolicyCallable(const PutResourcePolicyRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::PutResourcePolicy, request);
        }
 
        template<typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
        void PutResourcePolicyAsync(const PutResourcePolicyRequestT& request, const PutResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::PutResourcePolicy, request, handler, context);
        }
 
        virtual Model::StartDocumentClassificationJobOutcome StartDocumentClassificationJob(const Model::StartDocumentClassificationJobRequest& request) const;
 
        template<typename StartDocumentClassificationJobRequestT = Model::StartDocumentClassificationJobRequest>
        Model::StartDocumentClassificationJobOutcomeCallable StartDocumentClassificationJobCallable(const StartDocumentClassificationJobRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::StartDocumentClassificationJob, request);
        }
 
        template<typename StartDocumentClassificationJobRequestT = Model::StartDocumentClassificationJobRequest>
        void StartDocumentClassificationJobAsync(const StartDocumentClassificationJobRequestT& request, const StartDocumentClassificationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::StartDocumentClassificationJob, request, handler, context);
        }
 
        virtual Model::StartDominantLanguageDetectionJobOutcome StartDominantLanguageDetectionJob(const Model::StartDominantLanguageDetectionJobRequest& request) const;
 
        template<typename StartDominantLanguageDetectionJobRequestT = Model::StartDominantLanguageDetectionJobRequest>
        Model::StartDominantLanguageDetectionJobOutcomeCallable StartDominantLanguageDetectionJobCallable(const StartDominantLanguageDetectionJobRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::StartDominantLanguageDetectionJob, request);
        }
 
        template<typename StartDominantLanguageDetectionJobRequestT = Model::StartDominantLanguageDetectionJobRequest>
        void StartDominantLanguageDetectionJobAsync(const StartDominantLanguageDetectionJobRequestT& request, const StartDominantLanguageDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::StartDominantLanguageDetectionJob, request, handler, context);
        }
 
        virtual Model::StartEntitiesDetectionJobOutcome StartEntitiesDetectionJob(const Model::StartEntitiesDetectionJobRequest& request) const;
 
        template<typename StartEntitiesDetectionJobRequestT = Model::StartEntitiesDetectionJobRequest>
        Model::StartEntitiesDetectionJobOutcomeCallable StartEntitiesDetectionJobCallable(const StartEntitiesDetectionJobRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::StartEntitiesDetectionJob, request);
        }
 
        template<typename StartEntitiesDetectionJobRequestT = Model::StartEntitiesDetectionJobRequest>
        void StartEntitiesDetectionJobAsync(const StartEntitiesDetectionJobRequestT& request, const StartEntitiesDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::StartEntitiesDetectionJob, request, handler, context);
        }
 
        virtual Model::StartEventsDetectionJobOutcome StartEventsDetectionJob(const Model::StartEventsDetectionJobRequest& request) const;
 
        template<typename StartEventsDetectionJobRequestT = Model::StartEventsDetectionJobRequest>
        Model::StartEventsDetectionJobOutcomeCallable StartEventsDetectionJobCallable(const StartEventsDetectionJobRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::StartEventsDetectionJob, request);
        }
 
        template<typename StartEventsDetectionJobRequestT = Model::StartEventsDetectionJobRequest>
        void StartEventsDetectionJobAsync(const StartEventsDetectionJobRequestT& request, const StartEventsDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::StartEventsDetectionJob, request, handler, context);
        }
 
        virtual Model::StartFlywheelIterationOutcome StartFlywheelIteration(const Model::StartFlywheelIterationRequest& request) const;
 
        template<typename StartFlywheelIterationRequestT = Model::StartFlywheelIterationRequest>
        Model::StartFlywheelIterationOutcomeCallable StartFlywheelIterationCallable(const StartFlywheelIterationRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::StartFlywheelIteration, request);
        }
 
        template<typename StartFlywheelIterationRequestT = Model::StartFlywheelIterationRequest>
        void StartFlywheelIterationAsync(const StartFlywheelIterationRequestT& request, const StartFlywheelIterationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::StartFlywheelIteration, request, handler, context);
        }
 
        virtual Model::StartKeyPhrasesDetectionJobOutcome StartKeyPhrasesDetectionJob(const Model::StartKeyPhrasesDetectionJobRequest& request) const;
 
        template<typename StartKeyPhrasesDetectionJobRequestT = Model::StartKeyPhrasesDetectionJobRequest>
        Model::StartKeyPhrasesDetectionJobOutcomeCallable StartKeyPhrasesDetectionJobCallable(const StartKeyPhrasesDetectionJobRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::StartKeyPhrasesDetectionJob, request);
        }
 
        template<typename StartKeyPhrasesDetectionJobRequestT = Model::StartKeyPhrasesDetectionJobRequest>
        void StartKeyPhrasesDetectionJobAsync(const StartKeyPhrasesDetectionJobRequestT& request, const StartKeyPhrasesDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::StartKeyPhrasesDetectionJob, request, handler, context);
        }
 
        virtual Model::StartPiiEntitiesDetectionJobOutcome StartPiiEntitiesDetectionJob(const Model::StartPiiEntitiesDetectionJobRequest& request) const;
 
        template<typename StartPiiEntitiesDetectionJobRequestT = Model::StartPiiEntitiesDetectionJobRequest>
        Model::StartPiiEntitiesDetectionJobOutcomeCallable StartPiiEntitiesDetectionJobCallable(const StartPiiEntitiesDetectionJobRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::StartPiiEntitiesDetectionJob, request);
        }
 
        template<typename StartPiiEntitiesDetectionJobRequestT = Model::StartPiiEntitiesDetectionJobRequest>
        void StartPiiEntitiesDetectionJobAsync(const StartPiiEntitiesDetectionJobRequestT& request, const StartPiiEntitiesDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::StartPiiEntitiesDetectionJob, request, handler, context);
        }
 
        virtual Model::StartSentimentDetectionJobOutcome StartSentimentDetectionJob(const Model::StartSentimentDetectionJobRequest& request) const;
 
        template<typename StartSentimentDetectionJobRequestT = Model::StartSentimentDetectionJobRequest>
        Model::StartSentimentDetectionJobOutcomeCallable StartSentimentDetectionJobCallable(const StartSentimentDetectionJobRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::StartSentimentDetectionJob, request);
        }
 
        template<typename StartSentimentDetectionJobRequestT = Model::StartSentimentDetectionJobRequest>
        void StartSentimentDetectionJobAsync(const StartSentimentDetectionJobRequestT& request, const StartSentimentDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::StartSentimentDetectionJob, request, handler, context);
        }
 
        virtual Model::StartTargetedSentimentDetectionJobOutcome StartTargetedSentimentDetectionJob(const Model::StartTargetedSentimentDetectionJobRequest& request) const;
 
        template<typename StartTargetedSentimentDetectionJobRequestT = Model::StartTargetedSentimentDetectionJobRequest>
        Model::StartTargetedSentimentDetectionJobOutcomeCallable StartTargetedSentimentDetectionJobCallable(const StartTargetedSentimentDetectionJobRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::StartTargetedSentimentDetectionJob, request);
        }
 
        template<typename StartTargetedSentimentDetectionJobRequestT = Model::StartTargetedSentimentDetectionJobRequest>
        void StartTargetedSentimentDetectionJobAsync(const StartTargetedSentimentDetectionJobRequestT& request, const StartTargetedSentimentDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::StartTargetedSentimentDetectionJob, request, handler, context);
        }
 
        virtual Model::StartTopicsDetectionJobOutcome StartTopicsDetectionJob(const Model::StartTopicsDetectionJobRequest& request) const;
 
        template<typename StartTopicsDetectionJobRequestT = Model::StartTopicsDetectionJobRequest>
        Model::StartTopicsDetectionJobOutcomeCallable StartTopicsDetectionJobCallable(const StartTopicsDetectionJobRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::StartTopicsDetectionJob, request);
        }
 
        template<typename StartTopicsDetectionJobRequestT = Model::StartTopicsDetectionJobRequest>
        void StartTopicsDetectionJobAsync(const StartTopicsDetectionJobRequestT& request, const StartTopicsDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::StartTopicsDetectionJob, request, handler, context);
        }
 
        virtual Model::StopDominantLanguageDetectionJobOutcome StopDominantLanguageDetectionJob(const Model::StopDominantLanguageDetectionJobRequest& request) const;
 
        template<typename StopDominantLanguageDetectionJobRequestT = Model::StopDominantLanguageDetectionJobRequest>
        Model::StopDominantLanguageDetectionJobOutcomeCallable StopDominantLanguageDetectionJobCallable(const StopDominantLanguageDetectionJobRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::StopDominantLanguageDetectionJob, request);
        }
 
        template<typename StopDominantLanguageDetectionJobRequestT = Model::StopDominantLanguageDetectionJobRequest>
        void StopDominantLanguageDetectionJobAsync(const StopDominantLanguageDetectionJobRequestT& request, const StopDominantLanguageDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::StopDominantLanguageDetectionJob, request, handler, context);
        }
 
        virtual Model::StopEntitiesDetectionJobOutcome StopEntitiesDetectionJob(const Model::StopEntitiesDetectionJobRequest& request) const;
 
        template<typename StopEntitiesDetectionJobRequestT = Model::StopEntitiesDetectionJobRequest>
        Model::StopEntitiesDetectionJobOutcomeCallable StopEntitiesDetectionJobCallable(const StopEntitiesDetectionJobRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::StopEntitiesDetectionJob, request);
        }
 
        template<typename StopEntitiesDetectionJobRequestT = Model::StopEntitiesDetectionJobRequest>
        void StopEntitiesDetectionJobAsync(const StopEntitiesDetectionJobRequestT& request, const StopEntitiesDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::StopEntitiesDetectionJob, request, handler, context);
        }
 
        virtual Model::StopEventsDetectionJobOutcome StopEventsDetectionJob(const Model::StopEventsDetectionJobRequest& request) const;
 
        template<typename StopEventsDetectionJobRequestT = Model::StopEventsDetectionJobRequest>
        Model::StopEventsDetectionJobOutcomeCallable StopEventsDetectionJobCallable(const StopEventsDetectionJobRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::StopEventsDetectionJob, request);
        }
 
        template<typename StopEventsDetectionJobRequestT = Model::StopEventsDetectionJobRequest>
        void StopEventsDetectionJobAsync(const StopEventsDetectionJobRequestT& request, const StopEventsDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::StopEventsDetectionJob, request, handler, context);
        }
 
        virtual Model::StopKeyPhrasesDetectionJobOutcome StopKeyPhrasesDetectionJob(const Model::StopKeyPhrasesDetectionJobRequest& request) const;
 
        template<typename StopKeyPhrasesDetectionJobRequestT = Model::StopKeyPhrasesDetectionJobRequest>
        Model::StopKeyPhrasesDetectionJobOutcomeCallable StopKeyPhrasesDetectionJobCallable(const StopKeyPhrasesDetectionJobRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::StopKeyPhrasesDetectionJob, request);
        }
 
        template<typename StopKeyPhrasesDetectionJobRequestT = Model::StopKeyPhrasesDetectionJobRequest>
        void StopKeyPhrasesDetectionJobAsync(const StopKeyPhrasesDetectionJobRequestT& request, const StopKeyPhrasesDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::StopKeyPhrasesDetectionJob, request, handler, context);
        }
 
        virtual Model::StopPiiEntitiesDetectionJobOutcome StopPiiEntitiesDetectionJob(const Model::StopPiiEntitiesDetectionJobRequest& request) const;
 
        template<typename StopPiiEntitiesDetectionJobRequestT = Model::StopPiiEntitiesDetectionJobRequest>
        Model::StopPiiEntitiesDetectionJobOutcomeCallable StopPiiEntitiesDetectionJobCallable(const StopPiiEntitiesDetectionJobRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::StopPiiEntitiesDetectionJob, request);
        }
 
        template<typename StopPiiEntitiesDetectionJobRequestT = Model::StopPiiEntitiesDetectionJobRequest>
        void StopPiiEntitiesDetectionJobAsync(const StopPiiEntitiesDetectionJobRequestT& request, const StopPiiEntitiesDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::StopPiiEntitiesDetectionJob, request, handler, context);
        }
 
        virtual Model::StopSentimentDetectionJobOutcome StopSentimentDetectionJob(const Model::StopSentimentDetectionJobRequest& request) const;
 
        template<typename StopSentimentDetectionJobRequestT = Model::StopSentimentDetectionJobRequest>
        Model::StopSentimentDetectionJobOutcomeCallable StopSentimentDetectionJobCallable(const StopSentimentDetectionJobRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::StopSentimentDetectionJob, request);
        }
 
        template<typename StopSentimentDetectionJobRequestT = Model::StopSentimentDetectionJobRequest>
        void StopSentimentDetectionJobAsync(const StopSentimentDetectionJobRequestT& request, const StopSentimentDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::StopSentimentDetectionJob, request, handler, context);
        }
 
        virtual Model::StopTargetedSentimentDetectionJobOutcome StopTargetedSentimentDetectionJob(const Model::StopTargetedSentimentDetectionJobRequest& request) const;
 
        template<typename StopTargetedSentimentDetectionJobRequestT = Model::StopTargetedSentimentDetectionJobRequest>
        Model::StopTargetedSentimentDetectionJobOutcomeCallable StopTargetedSentimentDetectionJobCallable(const StopTargetedSentimentDetectionJobRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::StopTargetedSentimentDetectionJob, request);
        }
 
        template<typename StopTargetedSentimentDetectionJobRequestT = Model::StopTargetedSentimentDetectionJobRequest>
        void StopTargetedSentimentDetectionJobAsync(const StopTargetedSentimentDetectionJobRequestT& request, const StopTargetedSentimentDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::StopTargetedSentimentDetectionJob, request, handler, context);
        }
 
        virtual Model::StopTrainingDocumentClassifierOutcome StopTrainingDocumentClassifier(const Model::StopTrainingDocumentClassifierRequest& request) const;
 
        template<typename StopTrainingDocumentClassifierRequestT = Model::StopTrainingDocumentClassifierRequest>
        Model::StopTrainingDocumentClassifierOutcomeCallable StopTrainingDocumentClassifierCallable(const StopTrainingDocumentClassifierRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::StopTrainingDocumentClassifier, request);
        }
 
        template<typename StopTrainingDocumentClassifierRequestT = Model::StopTrainingDocumentClassifierRequest>
        void StopTrainingDocumentClassifierAsync(const StopTrainingDocumentClassifierRequestT& request, const StopTrainingDocumentClassifierResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::StopTrainingDocumentClassifier, request, handler, context);
        }
 
        virtual Model::StopTrainingEntityRecognizerOutcome StopTrainingEntityRecognizer(const Model::StopTrainingEntityRecognizerRequest& request) const;
 
        template<typename StopTrainingEntityRecognizerRequestT = Model::StopTrainingEntityRecognizerRequest>
        Model::StopTrainingEntityRecognizerOutcomeCallable StopTrainingEntityRecognizerCallable(const StopTrainingEntityRecognizerRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::StopTrainingEntityRecognizer, request);
        }
 
        template<typename StopTrainingEntityRecognizerRequestT = Model::StopTrainingEntityRecognizerRequest>
        void StopTrainingEntityRecognizerAsync(const StopTrainingEntityRecognizerRequestT& request, const StopTrainingEntityRecognizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::StopTrainingEntityRecognizer, request, handler, context);
        }
 
        virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
        template<typename TagResourceRequestT = Model::TagResourceRequest>
        Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::TagResource, request);
        }
 
        template<typename TagResourceRequestT = Model::TagResourceRequest>
        void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::TagResource, request, handler, context);
        }
 
        virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::UntagResource, request);
        }
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateEndpointOutcome UpdateEndpoint(const Model::UpdateEndpointRequest& request) const;
 
        template<typename UpdateEndpointRequestT = Model::UpdateEndpointRequest>
        Model::UpdateEndpointOutcomeCallable UpdateEndpointCallable(const UpdateEndpointRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::UpdateEndpoint, request);
        }
 
        template<typename UpdateEndpointRequestT = Model::UpdateEndpointRequest>
        void UpdateEndpointAsync(const UpdateEndpointRequestT& request, const UpdateEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::UpdateEndpoint, request, handler, context);
        }
 
        virtual Model::UpdateFlywheelOutcome UpdateFlywheel(const Model::UpdateFlywheelRequest& request) const;
 
        template<typename UpdateFlywheelRequestT = Model::UpdateFlywheelRequest>
        Model::UpdateFlywheelOutcomeCallable UpdateFlywheelCallable(const UpdateFlywheelRequestT& request) const
        {
            return SubmitCallable(&ComprehendClient::UpdateFlywheel, request);
        }
 
        template<typename UpdateFlywheelRequestT = Model::UpdateFlywheelRequest>
        void UpdateFlywheelAsync(const UpdateFlywheelRequestT& request, const UpdateFlywheelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ComprehendClient::UpdateFlywheel, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<ComprehendEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<ComprehendClient>;
      void init(const ComprehendClientConfiguration& clientConfiguration);
 
      ComprehendClientConfiguration m_clientConfiguration;
      std::shared_ptr<ComprehendEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Comprehend
} // namespace Aws