ComprehendMedicalClient.h

 
#pragma once
#include <aws/comprehendmedical/ComprehendMedicalPaginationBase.h>
#include <aws/comprehendmedical/ComprehendMedicalServiceClientModel.h>
#include <aws/comprehendmedical/ComprehendMedicalWaiter.h>
#include <aws/comprehendmedical/ComprehendMedical_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 ComprehendMedical {
class AWS_COMPREHENDMEDICAL_API ComprehendMedicalClient : public Aws::Client::AWSJsonClient,
                                                          public Aws::Client::ClientWithAsyncTemplateMethods<ComprehendMedicalClient>,
                                                          public ComprehendMedicalPaginationBase<ComprehendMedicalClient>,
                                                          public ComprehendMedicalWaiter<ComprehendMedicalClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef ComprehendMedicalClientConfiguration ClientConfigurationType;
  typedef ComprehendMedicalEndpointProvider EndpointProviderType;
 
  ComprehendMedicalClient(const Aws::ComprehendMedical::ComprehendMedicalClientConfiguration& clientConfiguration =
                              Aws::ComprehendMedical::ComprehendMedicalClientConfiguration(),
                          std::shared_ptr<ComprehendMedicalEndpointProviderBase> endpointProvider = nullptr);
 
  ComprehendMedicalClient(const Aws::Auth::AWSCredentials& credentials,
                          std::shared_ptr<ComprehendMedicalEndpointProviderBase> endpointProvider = nullptr,
                          const Aws::ComprehendMedical::ComprehendMedicalClientConfiguration& clientConfiguration =
                              Aws::ComprehendMedical::ComprehendMedicalClientConfiguration());
 
  ComprehendMedicalClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                          std::shared_ptr<ComprehendMedicalEndpointProviderBase> endpointProvider = nullptr,
                          const Aws::ComprehendMedical::ComprehendMedicalClientConfiguration& clientConfiguration =
                              Aws::ComprehendMedical::ComprehendMedicalClientConfiguration());
 
  /* Legacy constructors due deprecation */
  ComprehendMedicalClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ComprehendMedicalClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ComprehendMedicalClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                          const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~ComprehendMedicalClient();
 
  virtual Model::DescribeEntitiesDetectionV2JobOutcome DescribeEntitiesDetectionV2Job(
      const Model::DescribeEntitiesDetectionV2JobRequest& request) const;
 
  template <typename DescribeEntitiesDetectionV2JobRequestT = Model::DescribeEntitiesDetectionV2JobRequest>
  Model::DescribeEntitiesDetectionV2JobOutcomeCallable DescribeEntitiesDetectionV2JobCallable(
      const DescribeEntitiesDetectionV2JobRequestT& request) const {
    return SubmitCallable(&ComprehendMedicalClient::DescribeEntitiesDetectionV2Job, request);
  }
 
  template <typename DescribeEntitiesDetectionV2JobRequestT = Model::DescribeEntitiesDetectionV2JobRequest>
  void DescribeEntitiesDetectionV2JobAsync(const DescribeEntitiesDetectionV2JobRequestT& request,
                                           const DescribeEntitiesDetectionV2JobResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComprehendMedicalClient::DescribeEntitiesDetectionV2Job, request, handler, context);
  }
 
  virtual Model::DescribeICD10CMInferenceJobOutcome DescribeICD10CMInferenceJob(
      const Model::DescribeICD10CMInferenceJobRequest& request) const;
 
  template <typename DescribeICD10CMInferenceJobRequestT = Model::DescribeICD10CMInferenceJobRequest>
  Model::DescribeICD10CMInferenceJobOutcomeCallable DescribeICD10CMInferenceJobCallable(
      const DescribeICD10CMInferenceJobRequestT& request) const {
    return SubmitCallable(&ComprehendMedicalClient::DescribeICD10CMInferenceJob, request);
  }
 
  template <typename DescribeICD10CMInferenceJobRequestT = Model::DescribeICD10CMInferenceJobRequest>
  void DescribeICD10CMInferenceJobAsync(const DescribeICD10CMInferenceJobRequestT& request,
                                        const DescribeICD10CMInferenceJobResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComprehendMedicalClient::DescribeICD10CMInferenceJob, request, handler, context);
  }
 
  virtual Model::DescribePHIDetectionJobOutcome DescribePHIDetectionJob(const Model::DescribePHIDetectionJobRequest& request) const;
 
  template <typename DescribePHIDetectionJobRequestT = Model::DescribePHIDetectionJobRequest>
  Model::DescribePHIDetectionJobOutcomeCallable DescribePHIDetectionJobCallable(const DescribePHIDetectionJobRequestT& request) const {
    return SubmitCallable(&ComprehendMedicalClient::DescribePHIDetectionJob, request);
  }
 
  template <typename DescribePHIDetectionJobRequestT = Model::DescribePHIDetectionJobRequest>
  void DescribePHIDetectionJobAsync(const DescribePHIDetectionJobRequestT& request,
                                    const DescribePHIDetectionJobResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComprehendMedicalClient::DescribePHIDetectionJob, request, handler, context);
  }
 
  virtual Model::DescribeRxNormInferenceJobOutcome DescribeRxNormInferenceJob(
      const Model::DescribeRxNormInferenceJobRequest& request) const;
 
  template <typename DescribeRxNormInferenceJobRequestT = Model::DescribeRxNormInferenceJobRequest>
  Model::DescribeRxNormInferenceJobOutcomeCallable DescribeRxNormInferenceJobCallable(
      const DescribeRxNormInferenceJobRequestT& request) const {
    return SubmitCallable(&ComprehendMedicalClient::DescribeRxNormInferenceJob, request);
  }
 
  template <typename DescribeRxNormInferenceJobRequestT = Model::DescribeRxNormInferenceJobRequest>
  void DescribeRxNormInferenceJobAsync(const DescribeRxNormInferenceJobRequestT& request,
                                       const DescribeRxNormInferenceJobResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComprehendMedicalClient::DescribeRxNormInferenceJob, request, handler, context);
  }
 
  virtual Model::DescribeSNOMEDCTInferenceJobOutcome DescribeSNOMEDCTInferenceJob(
      const Model::DescribeSNOMEDCTInferenceJobRequest& request) const;
 
  template <typename DescribeSNOMEDCTInferenceJobRequestT = Model::DescribeSNOMEDCTInferenceJobRequest>
  Model::DescribeSNOMEDCTInferenceJobOutcomeCallable DescribeSNOMEDCTInferenceJobCallable(
      const DescribeSNOMEDCTInferenceJobRequestT& request) const {
    return SubmitCallable(&ComprehendMedicalClient::DescribeSNOMEDCTInferenceJob, request);
  }
 
  template <typename DescribeSNOMEDCTInferenceJobRequestT = Model::DescribeSNOMEDCTInferenceJobRequest>
  void DescribeSNOMEDCTInferenceJobAsync(const DescribeSNOMEDCTInferenceJobRequestT& request,
                                         const DescribeSNOMEDCTInferenceJobResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComprehendMedicalClient::DescribeSNOMEDCTInferenceJob, request, handler, context);
  }
 
  virtual Model::DetectEntitiesV2Outcome DetectEntitiesV2(const Model::DetectEntitiesV2Request& request) const;
 
  template <typename DetectEntitiesV2RequestT = Model::DetectEntitiesV2Request>
  Model::DetectEntitiesV2OutcomeCallable DetectEntitiesV2Callable(const DetectEntitiesV2RequestT& request) const {
    return SubmitCallable(&ComprehendMedicalClient::DetectEntitiesV2, request);
  }
 
  template <typename DetectEntitiesV2RequestT = Model::DetectEntitiesV2Request>
  void DetectEntitiesV2Async(const DetectEntitiesV2RequestT& request, const DetectEntitiesV2ResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComprehendMedicalClient::DetectEntitiesV2, request, handler, context);
  }
 
  virtual Model::DetectPHIOutcome DetectPHI(const Model::DetectPHIRequest& request) const;
 
  template <typename DetectPHIRequestT = Model::DetectPHIRequest>
  Model::DetectPHIOutcomeCallable DetectPHICallable(const DetectPHIRequestT& request) const {
    return SubmitCallable(&ComprehendMedicalClient::DetectPHI, request);
  }
 
  template <typename DetectPHIRequestT = Model::DetectPHIRequest>
  void DetectPHIAsync(const DetectPHIRequestT& request, const DetectPHIResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComprehendMedicalClient::DetectPHI, request, handler, context);
  }
 
  virtual Model::InferICD10CMOutcome InferICD10CM(const Model::InferICD10CMRequest& request) const;
 
  template <typename InferICD10CMRequestT = Model::InferICD10CMRequest>
  Model::InferICD10CMOutcomeCallable InferICD10CMCallable(const InferICD10CMRequestT& request) const {
    return SubmitCallable(&ComprehendMedicalClient::InferICD10CM, request);
  }
 
  template <typename InferICD10CMRequestT = Model::InferICD10CMRequest>
  void InferICD10CMAsync(const InferICD10CMRequestT& request, const InferICD10CMResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComprehendMedicalClient::InferICD10CM, request, handler, context);
  }
 
  virtual Model::InferRxNormOutcome InferRxNorm(const Model::InferRxNormRequest& request) const;
 
  template <typename InferRxNormRequestT = Model::InferRxNormRequest>
  Model::InferRxNormOutcomeCallable InferRxNormCallable(const InferRxNormRequestT& request) const {
    return SubmitCallable(&ComprehendMedicalClient::InferRxNorm, request);
  }
 
  template <typename InferRxNormRequestT = Model::InferRxNormRequest>
  void InferRxNormAsync(const InferRxNormRequestT& request, const InferRxNormResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComprehendMedicalClient::InferRxNorm, request, handler, context);
  }
 
  virtual Model::InferSNOMEDCTOutcome InferSNOMEDCT(const Model::InferSNOMEDCTRequest& request) const;
 
  template <typename InferSNOMEDCTRequestT = Model::InferSNOMEDCTRequest>
  Model::InferSNOMEDCTOutcomeCallable InferSNOMEDCTCallable(const InferSNOMEDCTRequestT& request) const {
    return SubmitCallable(&ComprehendMedicalClient::InferSNOMEDCT, request);
  }
 
  template <typename InferSNOMEDCTRequestT = Model::InferSNOMEDCTRequest>
  void InferSNOMEDCTAsync(const InferSNOMEDCTRequestT& request, const InferSNOMEDCTResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComprehendMedicalClient::InferSNOMEDCT, request, handler, context);
  }
 
  virtual Model::ListEntitiesDetectionV2JobsOutcome ListEntitiesDetectionV2Jobs(
      const Model::ListEntitiesDetectionV2JobsRequest& request = {}) const;
 
  template <typename ListEntitiesDetectionV2JobsRequestT = Model::ListEntitiesDetectionV2JobsRequest>
  Model::ListEntitiesDetectionV2JobsOutcomeCallable ListEntitiesDetectionV2JobsCallable(
      const ListEntitiesDetectionV2JobsRequestT& request = {}) const {
    return SubmitCallable(&ComprehendMedicalClient::ListEntitiesDetectionV2Jobs, request);
  }
 
  template <typename ListEntitiesDetectionV2JobsRequestT = Model::ListEntitiesDetectionV2JobsRequest>
  void ListEntitiesDetectionV2JobsAsync(const ListEntitiesDetectionV2JobsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const ListEntitiesDetectionV2JobsRequestT& request = {}) const {
    return SubmitAsync(&ComprehendMedicalClient::ListEntitiesDetectionV2Jobs, request, handler, context);
  }
 
  virtual Model::ListICD10CMInferenceJobsOutcome ListICD10CMInferenceJobs(const Model::ListICD10CMInferenceJobsRequest& request = {}) const;
 
  template <typename ListICD10CMInferenceJobsRequestT = Model::ListICD10CMInferenceJobsRequest>
  Model::ListICD10CMInferenceJobsOutcomeCallable ListICD10CMInferenceJobsCallable(
      const ListICD10CMInferenceJobsRequestT& request = {}) const {
    return SubmitCallable(&ComprehendMedicalClient::ListICD10CMInferenceJobs, request);
  }
 
  template <typename ListICD10CMInferenceJobsRequestT = Model::ListICD10CMInferenceJobsRequest>
  void ListICD10CMInferenceJobsAsync(const ListICD10CMInferenceJobsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const ListICD10CMInferenceJobsRequestT& request = {}) const {
    return SubmitAsync(&ComprehendMedicalClient::ListICD10CMInferenceJobs, request, handler, context);
  }
 
  virtual Model::ListPHIDetectionJobsOutcome ListPHIDetectionJobs(const Model::ListPHIDetectionJobsRequest& request = {}) const;
 
  template <typename ListPHIDetectionJobsRequestT = Model::ListPHIDetectionJobsRequest>
  Model::ListPHIDetectionJobsOutcomeCallable ListPHIDetectionJobsCallable(const ListPHIDetectionJobsRequestT& request = {}) const {
    return SubmitCallable(&ComprehendMedicalClient::ListPHIDetectionJobs, request);
  }
 
  template <typename ListPHIDetectionJobsRequestT = Model::ListPHIDetectionJobsRequest>
  void ListPHIDetectionJobsAsync(const ListPHIDetectionJobsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListPHIDetectionJobsRequestT& request = {}) const {
    return SubmitAsync(&ComprehendMedicalClient::ListPHIDetectionJobs, request, handler, context);
  }
 
  virtual Model::ListRxNormInferenceJobsOutcome ListRxNormInferenceJobs(const Model::ListRxNormInferenceJobsRequest& request = {}) const;
 
  template <typename ListRxNormInferenceJobsRequestT = Model::ListRxNormInferenceJobsRequest>
  Model::ListRxNormInferenceJobsOutcomeCallable ListRxNormInferenceJobsCallable(const ListRxNormInferenceJobsRequestT& request = {}) const {
    return SubmitCallable(&ComprehendMedicalClient::ListRxNormInferenceJobs, request);
  }
 
  template <typename ListRxNormInferenceJobsRequestT = Model::ListRxNormInferenceJobsRequest>
  void ListRxNormInferenceJobsAsync(const ListRxNormInferenceJobsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListRxNormInferenceJobsRequestT& request = {}) const {
    return SubmitAsync(&ComprehendMedicalClient::ListRxNormInferenceJobs, request, handler, context);
  }
 
  virtual Model::ListSNOMEDCTInferenceJobsOutcome ListSNOMEDCTInferenceJobs(
      const Model::ListSNOMEDCTInferenceJobsRequest& request = {}) const;
 
  template <typename ListSNOMEDCTInferenceJobsRequestT = Model::ListSNOMEDCTInferenceJobsRequest>
  Model::ListSNOMEDCTInferenceJobsOutcomeCallable ListSNOMEDCTInferenceJobsCallable(
      const ListSNOMEDCTInferenceJobsRequestT& request = {}) const {
    return SubmitCallable(&ComprehendMedicalClient::ListSNOMEDCTInferenceJobs, request);
  }
 
  template <typename ListSNOMEDCTInferenceJobsRequestT = Model::ListSNOMEDCTInferenceJobsRequest>
  void ListSNOMEDCTInferenceJobsAsync(const ListSNOMEDCTInferenceJobsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ListSNOMEDCTInferenceJobsRequestT& request = {}) const {
    return SubmitAsync(&ComprehendMedicalClient::ListSNOMEDCTInferenceJobs, request, handler, context);
  }
 
  virtual Model::StartEntitiesDetectionV2JobOutcome StartEntitiesDetectionV2Job(
      const Model::StartEntitiesDetectionV2JobRequest& request) const;
 
  template <typename StartEntitiesDetectionV2JobRequestT = Model::StartEntitiesDetectionV2JobRequest>
  Model::StartEntitiesDetectionV2JobOutcomeCallable StartEntitiesDetectionV2JobCallable(
      const StartEntitiesDetectionV2JobRequestT& request) const {
    return SubmitCallable(&ComprehendMedicalClient::StartEntitiesDetectionV2Job, request);
  }
 
  template <typename StartEntitiesDetectionV2JobRequestT = Model::StartEntitiesDetectionV2JobRequest>
  void StartEntitiesDetectionV2JobAsync(const StartEntitiesDetectionV2JobRequestT& request,
                                        const StartEntitiesDetectionV2JobResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComprehendMedicalClient::StartEntitiesDetectionV2Job, request, handler, context);
  }
 
  virtual Model::StartICD10CMInferenceJobOutcome StartICD10CMInferenceJob(const Model::StartICD10CMInferenceJobRequest& request) const;
 
  template <typename StartICD10CMInferenceJobRequestT = Model::StartICD10CMInferenceJobRequest>
  Model::StartICD10CMInferenceJobOutcomeCallable StartICD10CMInferenceJobCallable(const StartICD10CMInferenceJobRequestT& request) const {
    return SubmitCallable(&ComprehendMedicalClient::StartICD10CMInferenceJob, request);
  }
 
  template <typename StartICD10CMInferenceJobRequestT = Model::StartICD10CMInferenceJobRequest>
  void StartICD10CMInferenceJobAsync(const StartICD10CMInferenceJobRequestT& request,
                                     const StartICD10CMInferenceJobResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComprehendMedicalClient::StartICD10CMInferenceJob, request, handler, context);
  }
 
  virtual Model::StartPHIDetectionJobOutcome StartPHIDetectionJob(const Model::StartPHIDetectionJobRequest& request) const;
 
  template <typename StartPHIDetectionJobRequestT = Model::StartPHIDetectionJobRequest>
  Model::StartPHIDetectionJobOutcomeCallable StartPHIDetectionJobCallable(const StartPHIDetectionJobRequestT& request) const {
    return SubmitCallable(&ComprehendMedicalClient::StartPHIDetectionJob, request);
  }
 
  template <typename StartPHIDetectionJobRequestT = Model::StartPHIDetectionJobRequest>
  void StartPHIDetectionJobAsync(const StartPHIDetectionJobRequestT& request, const StartPHIDetectionJobResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComprehendMedicalClient::StartPHIDetectionJob, request, handler, context);
  }
 
  virtual Model::StartRxNormInferenceJobOutcome StartRxNormInferenceJob(const Model::StartRxNormInferenceJobRequest& request) const;
 
  template <typename StartRxNormInferenceJobRequestT = Model::StartRxNormInferenceJobRequest>
  Model::StartRxNormInferenceJobOutcomeCallable StartRxNormInferenceJobCallable(const StartRxNormInferenceJobRequestT& request) const {
    return SubmitCallable(&ComprehendMedicalClient::StartRxNormInferenceJob, request);
  }
 
  template <typename StartRxNormInferenceJobRequestT = Model::StartRxNormInferenceJobRequest>
  void StartRxNormInferenceJobAsync(const StartRxNormInferenceJobRequestT& request,
                                    const StartRxNormInferenceJobResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComprehendMedicalClient::StartRxNormInferenceJob, request, handler, context);
  }
 
  virtual Model::StartSNOMEDCTInferenceJobOutcome StartSNOMEDCTInferenceJob(const Model::StartSNOMEDCTInferenceJobRequest& request) const;
 
  template <typename StartSNOMEDCTInferenceJobRequestT = Model::StartSNOMEDCTInferenceJobRequest>
  Model::StartSNOMEDCTInferenceJobOutcomeCallable StartSNOMEDCTInferenceJobCallable(
      const StartSNOMEDCTInferenceJobRequestT& request) const {
    return SubmitCallable(&ComprehendMedicalClient::StartSNOMEDCTInferenceJob, request);
  }
 
  template <typename StartSNOMEDCTInferenceJobRequestT = Model::StartSNOMEDCTInferenceJobRequest>
  void StartSNOMEDCTInferenceJobAsync(const StartSNOMEDCTInferenceJobRequestT& request,
                                      const StartSNOMEDCTInferenceJobResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComprehendMedicalClient::StartSNOMEDCTInferenceJob, request, handler, context);
  }
 
  virtual Model::StopEntitiesDetectionV2JobOutcome StopEntitiesDetectionV2Job(
      const Model::StopEntitiesDetectionV2JobRequest& request) const;
 
  template <typename StopEntitiesDetectionV2JobRequestT = Model::StopEntitiesDetectionV2JobRequest>
  Model::StopEntitiesDetectionV2JobOutcomeCallable StopEntitiesDetectionV2JobCallable(
      const StopEntitiesDetectionV2JobRequestT& request) const {
    return SubmitCallable(&ComprehendMedicalClient::StopEntitiesDetectionV2Job, request);
  }
 
  template <typename StopEntitiesDetectionV2JobRequestT = Model::StopEntitiesDetectionV2JobRequest>
  void StopEntitiesDetectionV2JobAsync(const StopEntitiesDetectionV2JobRequestT& request,
                                       const StopEntitiesDetectionV2JobResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComprehendMedicalClient::StopEntitiesDetectionV2Job, request, handler, context);
  }
 
  virtual Model::StopICD10CMInferenceJobOutcome StopICD10CMInferenceJob(const Model::StopICD10CMInferenceJobRequest& request) const;
 
  template <typename StopICD10CMInferenceJobRequestT = Model::StopICD10CMInferenceJobRequest>
  Model::StopICD10CMInferenceJobOutcomeCallable StopICD10CMInferenceJobCallable(const StopICD10CMInferenceJobRequestT& request) const {
    return SubmitCallable(&ComprehendMedicalClient::StopICD10CMInferenceJob, request);
  }
 
  template <typename StopICD10CMInferenceJobRequestT = Model::StopICD10CMInferenceJobRequest>
  void StopICD10CMInferenceJobAsync(const StopICD10CMInferenceJobRequestT& request,
                                    const StopICD10CMInferenceJobResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComprehendMedicalClient::StopICD10CMInferenceJob, request, handler, context);
  }
 
  virtual Model::StopPHIDetectionJobOutcome StopPHIDetectionJob(const Model::StopPHIDetectionJobRequest& request) const;
 
  template <typename StopPHIDetectionJobRequestT = Model::StopPHIDetectionJobRequest>
  Model::StopPHIDetectionJobOutcomeCallable StopPHIDetectionJobCallable(const StopPHIDetectionJobRequestT& request) const {
    return SubmitCallable(&ComprehendMedicalClient::StopPHIDetectionJob, request);
  }
 
  template <typename StopPHIDetectionJobRequestT = Model::StopPHIDetectionJobRequest>
  void StopPHIDetectionJobAsync(const StopPHIDetectionJobRequestT& request, const StopPHIDetectionJobResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComprehendMedicalClient::StopPHIDetectionJob, request, handler, context);
  }
 
  virtual Model::StopRxNormInferenceJobOutcome StopRxNormInferenceJob(const Model::StopRxNormInferenceJobRequest& request) const;
 
  template <typename StopRxNormInferenceJobRequestT = Model::StopRxNormInferenceJobRequest>
  Model::StopRxNormInferenceJobOutcomeCallable StopRxNormInferenceJobCallable(const StopRxNormInferenceJobRequestT& request) const {
    return SubmitCallable(&ComprehendMedicalClient::StopRxNormInferenceJob, request);
  }
 
  template <typename StopRxNormInferenceJobRequestT = Model::StopRxNormInferenceJobRequest>
  void StopRxNormInferenceJobAsync(const StopRxNormInferenceJobRequestT& request,
                                   const StopRxNormInferenceJobResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComprehendMedicalClient::StopRxNormInferenceJob, request, handler, context);
  }
 
  virtual Model::StopSNOMEDCTInferenceJobOutcome StopSNOMEDCTInferenceJob(const Model::StopSNOMEDCTInferenceJobRequest& request) const;
 
  template <typename StopSNOMEDCTInferenceJobRequestT = Model::StopSNOMEDCTInferenceJobRequest>
  Model::StopSNOMEDCTInferenceJobOutcomeCallable StopSNOMEDCTInferenceJobCallable(const StopSNOMEDCTInferenceJobRequestT& request) const {
    return SubmitCallable(&ComprehendMedicalClient::StopSNOMEDCTInferenceJob, request);
  }
 
  template <typename StopSNOMEDCTInferenceJobRequestT = Model::StopSNOMEDCTInferenceJobRequest>
  void StopSNOMEDCTInferenceJobAsync(const StopSNOMEDCTInferenceJobRequestT& request,
                                     const StopSNOMEDCTInferenceJobResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComprehendMedicalClient::StopSNOMEDCTInferenceJob, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<ComprehendMedicalEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ComprehendMedicalClient>;
  void init(const ComprehendMedicalClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, ComprehendMedicalError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  ComprehendMedicalClientConfiguration m_clientConfiguration;
  std::shared_ptr<ComprehendMedicalEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace ComprehendMedical
}  // namespace Aws