ComprehendMedicalClient.h

 
#pragma once
#include <aws/comprehendmedical/ComprehendMedical_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/comprehendmedical/ComprehendMedicalServiceClientModel.h>
 
namespace Aws
{
namespace ComprehendMedical
{
  class AWS_COMPREHENDMEDICAL_API ComprehendMedicalClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<ComprehendMedicalEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<ComprehendMedicalClient>;
      void init(const ComprehendMedicalClientConfiguration& clientConfiguration);
 
      ComprehendMedicalClientConfiguration m_clientConfiguration;
      std::shared_ptr<ComprehendMedicalEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace ComprehendMedical
} // namespace Aws