TranscribeServiceClient.h

 
#pragma once
#include <aws/transcribe/TranscribeService_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/transcribe/TranscribeServiceServiceClientModel.h>
 
namespace Aws
{
namespace TranscribeService
{
  class AWS_TRANSCRIBESERVICE_API TranscribeServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<TranscribeServiceClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef TranscribeServiceClientConfiguration ClientConfigurationType;
      typedef TranscribeServiceEndpointProvider EndpointProviderType;
 
        TranscribeServiceClient(const Aws::TranscribeService::TranscribeServiceClientConfiguration& clientConfiguration = Aws::TranscribeService::TranscribeServiceClientConfiguration(),
                                std::shared_ptr<TranscribeServiceEndpointProviderBase> endpointProvider = nullptr);
 
        TranscribeServiceClient(const Aws::Auth::AWSCredentials& credentials,
                                std::shared_ptr<TranscribeServiceEndpointProviderBase> endpointProvider = nullptr,
                                const Aws::TranscribeService::TranscribeServiceClientConfiguration& clientConfiguration = Aws::TranscribeService::TranscribeServiceClientConfiguration());
 
        TranscribeServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                std::shared_ptr<TranscribeServiceEndpointProviderBase> endpointProvider = nullptr,
                                const Aws::TranscribeService::TranscribeServiceClientConfiguration& clientConfiguration = Aws::TranscribeService::TranscribeServiceClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        TranscribeServiceClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        TranscribeServiceClient(const Aws::Auth::AWSCredentials& credentials,
                                const Aws::Client::ClientConfiguration& clientConfiguration);
 
        TranscribeServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~TranscribeServiceClient();
 
        virtual Model::CreateCallAnalyticsCategoryOutcome CreateCallAnalyticsCategory(const Model::CreateCallAnalyticsCategoryRequest& request) const;
 
        template<typename CreateCallAnalyticsCategoryRequestT = Model::CreateCallAnalyticsCategoryRequest>
        Model::CreateCallAnalyticsCategoryOutcomeCallable CreateCallAnalyticsCategoryCallable(const CreateCallAnalyticsCategoryRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::CreateCallAnalyticsCategory, request);
        }
 
        template<typename CreateCallAnalyticsCategoryRequestT = Model::CreateCallAnalyticsCategoryRequest>
        void CreateCallAnalyticsCategoryAsync(const CreateCallAnalyticsCategoryRequestT& request, const CreateCallAnalyticsCategoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::CreateCallAnalyticsCategory, request, handler, context);
        }
 
        virtual Model::CreateLanguageModelOutcome CreateLanguageModel(const Model::CreateLanguageModelRequest& request) const;
 
        template<typename CreateLanguageModelRequestT = Model::CreateLanguageModelRequest>
        Model::CreateLanguageModelOutcomeCallable CreateLanguageModelCallable(const CreateLanguageModelRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::CreateLanguageModel, request);
        }
 
        template<typename CreateLanguageModelRequestT = Model::CreateLanguageModelRequest>
        void CreateLanguageModelAsync(const CreateLanguageModelRequestT& request, const CreateLanguageModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::CreateLanguageModel, request, handler, context);
        }
 
        virtual Model::CreateMedicalVocabularyOutcome CreateMedicalVocabulary(const Model::CreateMedicalVocabularyRequest& request) const;
 
        template<typename CreateMedicalVocabularyRequestT = Model::CreateMedicalVocabularyRequest>
        Model::CreateMedicalVocabularyOutcomeCallable CreateMedicalVocabularyCallable(const CreateMedicalVocabularyRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::CreateMedicalVocabulary, request);
        }
 
        template<typename CreateMedicalVocabularyRequestT = Model::CreateMedicalVocabularyRequest>
        void CreateMedicalVocabularyAsync(const CreateMedicalVocabularyRequestT& request, const CreateMedicalVocabularyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::CreateMedicalVocabulary, request, handler, context);
        }
 
        virtual Model::CreateVocabularyOutcome CreateVocabulary(const Model::CreateVocabularyRequest& request) const;
 
        template<typename CreateVocabularyRequestT = Model::CreateVocabularyRequest>
        Model::CreateVocabularyOutcomeCallable CreateVocabularyCallable(const CreateVocabularyRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::CreateVocabulary, request);
        }
 
        template<typename CreateVocabularyRequestT = Model::CreateVocabularyRequest>
        void CreateVocabularyAsync(const CreateVocabularyRequestT& request, const CreateVocabularyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::CreateVocabulary, request, handler, context);
        }
 
        virtual Model::CreateVocabularyFilterOutcome CreateVocabularyFilter(const Model::CreateVocabularyFilterRequest& request) const;
 
        template<typename CreateVocabularyFilterRequestT = Model::CreateVocabularyFilterRequest>
        Model::CreateVocabularyFilterOutcomeCallable CreateVocabularyFilterCallable(const CreateVocabularyFilterRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::CreateVocabularyFilter, request);
        }
 
        template<typename CreateVocabularyFilterRequestT = Model::CreateVocabularyFilterRequest>
        void CreateVocabularyFilterAsync(const CreateVocabularyFilterRequestT& request, const CreateVocabularyFilterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::CreateVocabularyFilter, request, handler, context);
        }
 
        virtual Model::DeleteCallAnalyticsCategoryOutcome DeleteCallAnalyticsCategory(const Model::DeleteCallAnalyticsCategoryRequest& request) const;
 
        template<typename DeleteCallAnalyticsCategoryRequestT = Model::DeleteCallAnalyticsCategoryRequest>
        Model::DeleteCallAnalyticsCategoryOutcomeCallable DeleteCallAnalyticsCategoryCallable(const DeleteCallAnalyticsCategoryRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::DeleteCallAnalyticsCategory, request);
        }
 
        template<typename DeleteCallAnalyticsCategoryRequestT = Model::DeleteCallAnalyticsCategoryRequest>
        void DeleteCallAnalyticsCategoryAsync(const DeleteCallAnalyticsCategoryRequestT& request, const DeleteCallAnalyticsCategoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::DeleteCallAnalyticsCategory, request, handler, context);
        }
 
        virtual Model::DeleteCallAnalyticsJobOutcome DeleteCallAnalyticsJob(const Model::DeleteCallAnalyticsJobRequest& request) const;
 
        template<typename DeleteCallAnalyticsJobRequestT = Model::DeleteCallAnalyticsJobRequest>
        Model::DeleteCallAnalyticsJobOutcomeCallable DeleteCallAnalyticsJobCallable(const DeleteCallAnalyticsJobRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::DeleteCallAnalyticsJob, request);
        }
 
        template<typename DeleteCallAnalyticsJobRequestT = Model::DeleteCallAnalyticsJobRequest>
        void DeleteCallAnalyticsJobAsync(const DeleteCallAnalyticsJobRequestT& request, const DeleteCallAnalyticsJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::DeleteCallAnalyticsJob, request, handler, context);
        }
 
        virtual Model::DeleteLanguageModelOutcome DeleteLanguageModel(const Model::DeleteLanguageModelRequest& request) const;
 
        template<typename DeleteLanguageModelRequestT = Model::DeleteLanguageModelRequest>
        Model::DeleteLanguageModelOutcomeCallable DeleteLanguageModelCallable(const DeleteLanguageModelRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::DeleteLanguageModel, request);
        }
 
        template<typename DeleteLanguageModelRequestT = Model::DeleteLanguageModelRequest>
        void DeleteLanguageModelAsync(const DeleteLanguageModelRequestT& request, const DeleteLanguageModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::DeleteLanguageModel, request, handler, context);
        }
 
        virtual Model::DeleteMedicalScribeJobOutcome DeleteMedicalScribeJob(const Model::DeleteMedicalScribeJobRequest& request) const;
 
        template<typename DeleteMedicalScribeJobRequestT = Model::DeleteMedicalScribeJobRequest>
        Model::DeleteMedicalScribeJobOutcomeCallable DeleteMedicalScribeJobCallable(const DeleteMedicalScribeJobRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::DeleteMedicalScribeJob, request);
        }
 
        template<typename DeleteMedicalScribeJobRequestT = Model::DeleteMedicalScribeJobRequest>
        void DeleteMedicalScribeJobAsync(const DeleteMedicalScribeJobRequestT& request, const DeleteMedicalScribeJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::DeleteMedicalScribeJob, request, handler, context);
        }
 
        virtual Model::DeleteMedicalTranscriptionJobOutcome DeleteMedicalTranscriptionJob(const Model::DeleteMedicalTranscriptionJobRequest& request) const;
 
        template<typename DeleteMedicalTranscriptionJobRequestT = Model::DeleteMedicalTranscriptionJobRequest>
        Model::DeleteMedicalTranscriptionJobOutcomeCallable DeleteMedicalTranscriptionJobCallable(const DeleteMedicalTranscriptionJobRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::DeleteMedicalTranscriptionJob, request);
        }
 
        template<typename DeleteMedicalTranscriptionJobRequestT = Model::DeleteMedicalTranscriptionJobRequest>
        void DeleteMedicalTranscriptionJobAsync(const DeleteMedicalTranscriptionJobRequestT& request, const DeleteMedicalTranscriptionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::DeleteMedicalTranscriptionJob, request, handler, context);
        }
 
        virtual Model::DeleteMedicalVocabularyOutcome DeleteMedicalVocabulary(const Model::DeleteMedicalVocabularyRequest& request) const;
 
        template<typename DeleteMedicalVocabularyRequestT = Model::DeleteMedicalVocabularyRequest>
        Model::DeleteMedicalVocabularyOutcomeCallable DeleteMedicalVocabularyCallable(const DeleteMedicalVocabularyRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::DeleteMedicalVocabulary, request);
        }
 
        template<typename DeleteMedicalVocabularyRequestT = Model::DeleteMedicalVocabularyRequest>
        void DeleteMedicalVocabularyAsync(const DeleteMedicalVocabularyRequestT& request, const DeleteMedicalVocabularyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::DeleteMedicalVocabulary, request, handler, context);
        }
 
        virtual Model::DeleteTranscriptionJobOutcome DeleteTranscriptionJob(const Model::DeleteTranscriptionJobRequest& request) const;
 
        template<typename DeleteTranscriptionJobRequestT = Model::DeleteTranscriptionJobRequest>
        Model::DeleteTranscriptionJobOutcomeCallable DeleteTranscriptionJobCallable(const DeleteTranscriptionJobRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::DeleteTranscriptionJob, request);
        }
 
        template<typename DeleteTranscriptionJobRequestT = Model::DeleteTranscriptionJobRequest>
        void DeleteTranscriptionJobAsync(const DeleteTranscriptionJobRequestT& request, const DeleteTranscriptionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::DeleteTranscriptionJob, request, handler, context);
        }
 
        virtual Model::DeleteVocabularyOutcome DeleteVocabulary(const Model::DeleteVocabularyRequest& request) const;
 
        template<typename DeleteVocabularyRequestT = Model::DeleteVocabularyRequest>
        Model::DeleteVocabularyOutcomeCallable DeleteVocabularyCallable(const DeleteVocabularyRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::DeleteVocabulary, request);
        }
 
        template<typename DeleteVocabularyRequestT = Model::DeleteVocabularyRequest>
        void DeleteVocabularyAsync(const DeleteVocabularyRequestT& request, const DeleteVocabularyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::DeleteVocabulary, request, handler, context);
        }
 
        virtual Model::DeleteVocabularyFilterOutcome DeleteVocabularyFilter(const Model::DeleteVocabularyFilterRequest& request) const;
 
        template<typename DeleteVocabularyFilterRequestT = Model::DeleteVocabularyFilterRequest>
        Model::DeleteVocabularyFilterOutcomeCallable DeleteVocabularyFilterCallable(const DeleteVocabularyFilterRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::DeleteVocabularyFilter, request);
        }
 
        template<typename DeleteVocabularyFilterRequestT = Model::DeleteVocabularyFilterRequest>
        void DeleteVocabularyFilterAsync(const DeleteVocabularyFilterRequestT& request, const DeleteVocabularyFilterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::DeleteVocabularyFilter, request, handler, context);
        }
 
        virtual Model::DescribeLanguageModelOutcome DescribeLanguageModel(const Model::DescribeLanguageModelRequest& request) const;
 
        template<typename DescribeLanguageModelRequestT = Model::DescribeLanguageModelRequest>
        Model::DescribeLanguageModelOutcomeCallable DescribeLanguageModelCallable(const DescribeLanguageModelRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::DescribeLanguageModel, request);
        }
 
        template<typename DescribeLanguageModelRequestT = Model::DescribeLanguageModelRequest>
        void DescribeLanguageModelAsync(const DescribeLanguageModelRequestT& request, const DescribeLanguageModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::DescribeLanguageModel, request, handler, context);
        }
 
        virtual Model::GetCallAnalyticsCategoryOutcome GetCallAnalyticsCategory(const Model::GetCallAnalyticsCategoryRequest& request) const;
 
        template<typename GetCallAnalyticsCategoryRequestT = Model::GetCallAnalyticsCategoryRequest>
        Model::GetCallAnalyticsCategoryOutcomeCallable GetCallAnalyticsCategoryCallable(const GetCallAnalyticsCategoryRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::GetCallAnalyticsCategory, request);
        }
 
        template<typename GetCallAnalyticsCategoryRequestT = Model::GetCallAnalyticsCategoryRequest>
        void GetCallAnalyticsCategoryAsync(const GetCallAnalyticsCategoryRequestT& request, const GetCallAnalyticsCategoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::GetCallAnalyticsCategory, request, handler, context);
        }
 
        virtual Model::GetCallAnalyticsJobOutcome GetCallAnalyticsJob(const Model::GetCallAnalyticsJobRequest& request) const;
 
        template<typename GetCallAnalyticsJobRequestT = Model::GetCallAnalyticsJobRequest>
        Model::GetCallAnalyticsJobOutcomeCallable GetCallAnalyticsJobCallable(const GetCallAnalyticsJobRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::GetCallAnalyticsJob, request);
        }
 
        template<typename GetCallAnalyticsJobRequestT = Model::GetCallAnalyticsJobRequest>
        void GetCallAnalyticsJobAsync(const GetCallAnalyticsJobRequestT& request, const GetCallAnalyticsJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::GetCallAnalyticsJob, request, handler, context);
        }
 
        virtual Model::GetMedicalScribeJobOutcome GetMedicalScribeJob(const Model::GetMedicalScribeJobRequest& request) const;
 
        template<typename GetMedicalScribeJobRequestT = Model::GetMedicalScribeJobRequest>
        Model::GetMedicalScribeJobOutcomeCallable GetMedicalScribeJobCallable(const GetMedicalScribeJobRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::GetMedicalScribeJob, request);
        }
 
        template<typename GetMedicalScribeJobRequestT = Model::GetMedicalScribeJobRequest>
        void GetMedicalScribeJobAsync(const GetMedicalScribeJobRequestT& request, const GetMedicalScribeJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::GetMedicalScribeJob, request, handler, context);
        }
 
        virtual Model::GetMedicalTranscriptionJobOutcome GetMedicalTranscriptionJob(const Model::GetMedicalTranscriptionJobRequest& request) const;
 
        template<typename GetMedicalTranscriptionJobRequestT = Model::GetMedicalTranscriptionJobRequest>
        Model::GetMedicalTranscriptionJobOutcomeCallable GetMedicalTranscriptionJobCallable(const GetMedicalTranscriptionJobRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::GetMedicalTranscriptionJob, request);
        }
 
        template<typename GetMedicalTranscriptionJobRequestT = Model::GetMedicalTranscriptionJobRequest>
        void GetMedicalTranscriptionJobAsync(const GetMedicalTranscriptionJobRequestT& request, const GetMedicalTranscriptionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::GetMedicalTranscriptionJob, request, handler, context);
        }
 
        virtual Model::GetMedicalVocabularyOutcome GetMedicalVocabulary(const Model::GetMedicalVocabularyRequest& request) const;
 
        template<typename GetMedicalVocabularyRequestT = Model::GetMedicalVocabularyRequest>
        Model::GetMedicalVocabularyOutcomeCallable GetMedicalVocabularyCallable(const GetMedicalVocabularyRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::GetMedicalVocabulary, request);
        }
 
        template<typename GetMedicalVocabularyRequestT = Model::GetMedicalVocabularyRequest>
        void GetMedicalVocabularyAsync(const GetMedicalVocabularyRequestT& request, const GetMedicalVocabularyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::GetMedicalVocabulary, request, handler, context);
        }
 
        virtual Model::GetTranscriptionJobOutcome GetTranscriptionJob(const Model::GetTranscriptionJobRequest& request) const;
 
        template<typename GetTranscriptionJobRequestT = Model::GetTranscriptionJobRequest>
        Model::GetTranscriptionJobOutcomeCallable GetTranscriptionJobCallable(const GetTranscriptionJobRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::GetTranscriptionJob, request);
        }
 
        template<typename GetTranscriptionJobRequestT = Model::GetTranscriptionJobRequest>
        void GetTranscriptionJobAsync(const GetTranscriptionJobRequestT& request, const GetTranscriptionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::GetTranscriptionJob, request, handler, context);
        }
 
        virtual Model::GetVocabularyOutcome GetVocabulary(const Model::GetVocabularyRequest& request) const;
 
        template<typename GetVocabularyRequestT = Model::GetVocabularyRequest>
        Model::GetVocabularyOutcomeCallable GetVocabularyCallable(const GetVocabularyRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::GetVocabulary, request);
        }
 
        template<typename GetVocabularyRequestT = Model::GetVocabularyRequest>
        void GetVocabularyAsync(const GetVocabularyRequestT& request, const GetVocabularyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::GetVocabulary, request, handler, context);
        }
 
        virtual Model::GetVocabularyFilterOutcome GetVocabularyFilter(const Model::GetVocabularyFilterRequest& request) const;
 
        template<typename GetVocabularyFilterRequestT = Model::GetVocabularyFilterRequest>
        Model::GetVocabularyFilterOutcomeCallable GetVocabularyFilterCallable(const GetVocabularyFilterRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::GetVocabularyFilter, request);
        }
 
        template<typename GetVocabularyFilterRequestT = Model::GetVocabularyFilterRequest>
        void GetVocabularyFilterAsync(const GetVocabularyFilterRequestT& request, const GetVocabularyFilterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::GetVocabularyFilter, request, handler, context);
        }
 
        virtual Model::ListCallAnalyticsCategoriesOutcome ListCallAnalyticsCategories(const Model::ListCallAnalyticsCategoriesRequest& request = {}) const;
 
        template<typename ListCallAnalyticsCategoriesRequestT = Model::ListCallAnalyticsCategoriesRequest>
        Model::ListCallAnalyticsCategoriesOutcomeCallable ListCallAnalyticsCategoriesCallable(const ListCallAnalyticsCategoriesRequestT& request = {}) const
        {
            return SubmitCallable(&TranscribeServiceClient::ListCallAnalyticsCategories, request);
        }
 
        template<typename ListCallAnalyticsCategoriesRequestT = Model::ListCallAnalyticsCategoriesRequest>
        void ListCallAnalyticsCategoriesAsync(const ListCallAnalyticsCategoriesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCallAnalyticsCategoriesRequestT& request = {}) const
        {
            return SubmitAsync(&TranscribeServiceClient::ListCallAnalyticsCategories, request, handler, context);
        }
 
        virtual Model::ListCallAnalyticsJobsOutcome ListCallAnalyticsJobs(const Model::ListCallAnalyticsJobsRequest& request = {}) const;
 
        template<typename ListCallAnalyticsJobsRequestT = Model::ListCallAnalyticsJobsRequest>
        Model::ListCallAnalyticsJobsOutcomeCallable ListCallAnalyticsJobsCallable(const ListCallAnalyticsJobsRequestT& request = {}) const
        {
            return SubmitCallable(&TranscribeServiceClient::ListCallAnalyticsJobs, request);
        }
 
        template<typename ListCallAnalyticsJobsRequestT = Model::ListCallAnalyticsJobsRequest>
        void ListCallAnalyticsJobsAsync(const ListCallAnalyticsJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCallAnalyticsJobsRequestT& request = {}) const
        {
            return SubmitAsync(&TranscribeServiceClient::ListCallAnalyticsJobs, request, handler, context);
        }
 
        virtual Model::ListLanguageModelsOutcome ListLanguageModels(const Model::ListLanguageModelsRequest& request = {}) const;
 
        template<typename ListLanguageModelsRequestT = Model::ListLanguageModelsRequest>
        Model::ListLanguageModelsOutcomeCallable ListLanguageModelsCallable(const ListLanguageModelsRequestT& request = {}) const
        {
            return SubmitCallable(&TranscribeServiceClient::ListLanguageModels, request);
        }
 
        template<typename ListLanguageModelsRequestT = Model::ListLanguageModelsRequest>
        void ListLanguageModelsAsync(const ListLanguageModelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListLanguageModelsRequestT& request = {}) const
        {
            return SubmitAsync(&TranscribeServiceClient::ListLanguageModels, request, handler, context);
        }
 
        virtual Model::ListMedicalScribeJobsOutcome ListMedicalScribeJobs(const Model::ListMedicalScribeJobsRequest& request = {}) const;
 
        template<typename ListMedicalScribeJobsRequestT = Model::ListMedicalScribeJobsRequest>
        Model::ListMedicalScribeJobsOutcomeCallable ListMedicalScribeJobsCallable(const ListMedicalScribeJobsRequestT& request = {}) const
        {
            return SubmitCallable(&TranscribeServiceClient::ListMedicalScribeJobs, request);
        }
 
        template<typename ListMedicalScribeJobsRequestT = Model::ListMedicalScribeJobsRequest>
        void ListMedicalScribeJobsAsync(const ListMedicalScribeJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListMedicalScribeJobsRequestT& request = {}) const
        {
            return SubmitAsync(&TranscribeServiceClient::ListMedicalScribeJobs, request, handler, context);
        }
 
        virtual Model::ListMedicalTranscriptionJobsOutcome ListMedicalTranscriptionJobs(const Model::ListMedicalTranscriptionJobsRequest& request = {}) const;
 
        template<typename ListMedicalTranscriptionJobsRequestT = Model::ListMedicalTranscriptionJobsRequest>
        Model::ListMedicalTranscriptionJobsOutcomeCallable ListMedicalTranscriptionJobsCallable(const ListMedicalTranscriptionJobsRequestT& request = {}) const
        {
            return SubmitCallable(&TranscribeServiceClient::ListMedicalTranscriptionJobs, request);
        }
 
        template<typename ListMedicalTranscriptionJobsRequestT = Model::ListMedicalTranscriptionJobsRequest>
        void ListMedicalTranscriptionJobsAsync(const ListMedicalTranscriptionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListMedicalTranscriptionJobsRequestT& request = {}) const
        {
            return SubmitAsync(&TranscribeServiceClient::ListMedicalTranscriptionJobs, request, handler, context);
        }
 
        virtual Model::ListMedicalVocabulariesOutcome ListMedicalVocabularies(const Model::ListMedicalVocabulariesRequest& request = {}) const;
 
        template<typename ListMedicalVocabulariesRequestT = Model::ListMedicalVocabulariesRequest>
        Model::ListMedicalVocabulariesOutcomeCallable ListMedicalVocabulariesCallable(const ListMedicalVocabulariesRequestT& request = {}) const
        {
            return SubmitCallable(&TranscribeServiceClient::ListMedicalVocabularies, request);
        }
 
        template<typename ListMedicalVocabulariesRequestT = Model::ListMedicalVocabulariesRequest>
        void ListMedicalVocabulariesAsync(const ListMedicalVocabulariesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListMedicalVocabulariesRequestT& request = {}) const
        {
            return SubmitAsync(&TranscribeServiceClient::ListMedicalVocabularies, 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(&TranscribeServiceClient::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(&TranscribeServiceClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListTranscriptionJobsOutcome ListTranscriptionJobs(const Model::ListTranscriptionJobsRequest& request = {}) const;
 
        template<typename ListTranscriptionJobsRequestT = Model::ListTranscriptionJobsRequest>
        Model::ListTranscriptionJobsOutcomeCallable ListTranscriptionJobsCallable(const ListTranscriptionJobsRequestT& request = {}) const
        {
            return SubmitCallable(&TranscribeServiceClient::ListTranscriptionJobs, request);
        }
 
        template<typename ListTranscriptionJobsRequestT = Model::ListTranscriptionJobsRequest>
        void ListTranscriptionJobsAsync(const ListTranscriptionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTranscriptionJobsRequestT& request = {}) const
        {
            return SubmitAsync(&TranscribeServiceClient::ListTranscriptionJobs, request, handler, context);
        }
 
        virtual Model::ListVocabulariesOutcome ListVocabularies(const Model::ListVocabulariesRequest& request = {}) const;
 
        template<typename ListVocabulariesRequestT = Model::ListVocabulariesRequest>
        Model::ListVocabulariesOutcomeCallable ListVocabulariesCallable(const ListVocabulariesRequestT& request = {}) const
        {
            return SubmitCallable(&TranscribeServiceClient::ListVocabularies, request);
        }
 
        template<typename ListVocabulariesRequestT = Model::ListVocabulariesRequest>
        void ListVocabulariesAsync(const ListVocabulariesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListVocabulariesRequestT& request = {}) const
        {
            return SubmitAsync(&TranscribeServiceClient::ListVocabularies, request, handler, context);
        }
 
        virtual Model::ListVocabularyFiltersOutcome ListVocabularyFilters(const Model::ListVocabularyFiltersRequest& request = {}) const;
 
        template<typename ListVocabularyFiltersRequestT = Model::ListVocabularyFiltersRequest>
        Model::ListVocabularyFiltersOutcomeCallable ListVocabularyFiltersCallable(const ListVocabularyFiltersRequestT& request = {}) const
        {
            return SubmitCallable(&TranscribeServiceClient::ListVocabularyFilters, request);
        }
 
        template<typename ListVocabularyFiltersRequestT = Model::ListVocabularyFiltersRequest>
        void ListVocabularyFiltersAsync(const ListVocabularyFiltersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListVocabularyFiltersRequestT& request = {}) const
        {
            return SubmitAsync(&TranscribeServiceClient::ListVocabularyFilters, request, handler, context);
        }
 
        virtual Model::StartCallAnalyticsJobOutcome StartCallAnalyticsJob(const Model::StartCallAnalyticsJobRequest& request) const;
 
        template<typename StartCallAnalyticsJobRequestT = Model::StartCallAnalyticsJobRequest>
        Model::StartCallAnalyticsJobOutcomeCallable StartCallAnalyticsJobCallable(const StartCallAnalyticsJobRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::StartCallAnalyticsJob, request);
        }
 
        template<typename StartCallAnalyticsJobRequestT = Model::StartCallAnalyticsJobRequest>
        void StartCallAnalyticsJobAsync(const StartCallAnalyticsJobRequestT& request, const StartCallAnalyticsJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::StartCallAnalyticsJob, request, handler, context);
        }
 
        virtual Model::StartMedicalScribeJobOutcome StartMedicalScribeJob(const Model::StartMedicalScribeJobRequest& request) const;
 
        template<typename StartMedicalScribeJobRequestT = Model::StartMedicalScribeJobRequest>
        Model::StartMedicalScribeJobOutcomeCallable StartMedicalScribeJobCallable(const StartMedicalScribeJobRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::StartMedicalScribeJob, request);
        }
 
        template<typename StartMedicalScribeJobRequestT = Model::StartMedicalScribeJobRequest>
        void StartMedicalScribeJobAsync(const StartMedicalScribeJobRequestT& request, const StartMedicalScribeJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::StartMedicalScribeJob, request, handler, context);
        }
 
        virtual Model::StartMedicalTranscriptionJobOutcome StartMedicalTranscriptionJob(const Model::StartMedicalTranscriptionJobRequest& request) const;
 
        template<typename StartMedicalTranscriptionJobRequestT = Model::StartMedicalTranscriptionJobRequest>
        Model::StartMedicalTranscriptionJobOutcomeCallable StartMedicalTranscriptionJobCallable(const StartMedicalTranscriptionJobRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::StartMedicalTranscriptionJob, request);
        }
 
        template<typename StartMedicalTranscriptionJobRequestT = Model::StartMedicalTranscriptionJobRequest>
        void StartMedicalTranscriptionJobAsync(const StartMedicalTranscriptionJobRequestT& request, const StartMedicalTranscriptionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::StartMedicalTranscriptionJob, request, handler, context);
        }
 
        virtual Model::StartTranscriptionJobOutcome StartTranscriptionJob(const Model::StartTranscriptionJobRequest& request) const;
 
        template<typename StartTranscriptionJobRequestT = Model::StartTranscriptionJobRequest>
        Model::StartTranscriptionJobOutcomeCallable StartTranscriptionJobCallable(const StartTranscriptionJobRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::StartTranscriptionJob, request);
        }
 
        template<typename StartTranscriptionJobRequestT = Model::StartTranscriptionJobRequest>
        void StartTranscriptionJobAsync(const StartTranscriptionJobRequestT& request, const StartTranscriptionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::StartTranscriptionJob, 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(&TranscribeServiceClient::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(&TranscribeServiceClient::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(&TranscribeServiceClient::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(&TranscribeServiceClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateCallAnalyticsCategoryOutcome UpdateCallAnalyticsCategory(const Model::UpdateCallAnalyticsCategoryRequest& request) const;
 
        template<typename UpdateCallAnalyticsCategoryRequestT = Model::UpdateCallAnalyticsCategoryRequest>
        Model::UpdateCallAnalyticsCategoryOutcomeCallable UpdateCallAnalyticsCategoryCallable(const UpdateCallAnalyticsCategoryRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::UpdateCallAnalyticsCategory, request);
        }
 
        template<typename UpdateCallAnalyticsCategoryRequestT = Model::UpdateCallAnalyticsCategoryRequest>
        void UpdateCallAnalyticsCategoryAsync(const UpdateCallAnalyticsCategoryRequestT& request, const UpdateCallAnalyticsCategoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::UpdateCallAnalyticsCategory, request, handler, context);
        }
 
        virtual Model::UpdateMedicalVocabularyOutcome UpdateMedicalVocabulary(const Model::UpdateMedicalVocabularyRequest& request) const;
 
        template<typename UpdateMedicalVocabularyRequestT = Model::UpdateMedicalVocabularyRequest>
        Model::UpdateMedicalVocabularyOutcomeCallable UpdateMedicalVocabularyCallable(const UpdateMedicalVocabularyRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::UpdateMedicalVocabulary, request);
        }
 
        template<typename UpdateMedicalVocabularyRequestT = Model::UpdateMedicalVocabularyRequest>
        void UpdateMedicalVocabularyAsync(const UpdateMedicalVocabularyRequestT& request, const UpdateMedicalVocabularyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::UpdateMedicalVocabulary, request, handler, context);
        }
 
        virtual Model::UpdateVocabularyOutcome UpdateVocabulary(const Model::UpdateVocabularyRequest& request) const;
 
        template<typename UpdateVocabularyRequestT = Model::UpdateVocabularyRequest>
        Model::UpdateVocabularyOutcomeCallable UpdateVocabularyCallable(const UpdateVocabularyRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::UpdateVocabulary, request);
        }
 
        template<typename UpdateVocabularyRequestT = Model::UpdateVocabularyRequest>
        void UpdateVocabularyAsync(const UpdateVocabularyRequestT& request, const UpdateVocabularyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::UpdateVocabulary, request, handler, context);
        }
 
        virtual Model::UpdateVocabularyFilterOutcome UpdateVocabularyFilter(const Model::UpdateVocabularyFilterRequest& request) const;
 
        template<typename UpdateVocabularyFilterRequestT = Model::UpdateVocabularyFilterRequest>
        Model::UpdateVocabularyFilterOutcomeCallable UpdateVocabularyFilterCallable(const UpdateVocabularyFilterRequestT& request) const
        {
            return SubmitCallable(&TranscribeServiceClient::UpdateVocabularyFilter, request);
        }
 
        template<typename UpdateVocabularyFilterRequestT = Model::UpdateVocabularyFilterRequest>
        void UpdateVocabularyFilterAsync(const UpdateVocabularyFilterRequestT& request, const UpdateVocabularyFilterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TranscribeServiceClient::UpdateVocabularyFilter, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<TranscribeServiceEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<TranscribeServiceClient>;
      void init(const TranscribeServiceClientConfiguration& clientConfiguration);
 
      TranscribeServiceClientConfiguration m_clientConfiguration;
      std::shared_ptr<TranscribeServiceEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace TranscribeService
} // namespace Aws