ComprehendClient.h

 
#pragma once
#include <aws/comprehend/ComprehendServiceClientModel.h>
#include <aws/comprehend/Comprehend_EXPORTS.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
 
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