TranscribeServiceClient.h

 
#pragma once
#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>
#include <aws/transcribe/TranscribeServicePaginationBase.h>
#include <aws/transcribe/TranscribeServiceServiceClientModel.h>
#include <aws/transcribe/TranscribeServiceWaiter.h>
#include <aws/transcribe/TranscribeService_EXPORTS.h>
 
namespace Aws {
namespace TranscribeService {
class AWS_TRANSCRIBESERVICE_API TranscribeServiceClient : public Aws::Client::AWSJsonClient,
                                                          public Aws::Client::ClientWithAsyncTemplateMethods<TranscribeServiceClient>,
                                                          public TranscribeServicePaginationBase<TranscribeServiceClient>,
                                                          public TranscribeServiceWaiter<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<TranscribeServiceEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<TranscribeServiceClient>;
  void init(const TranscribeServiceClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, TranscribeServiceError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  TranscribeServiceClientConfiguration m_clientConfiguration;
  std::shared_ptr<TranscribeServiceEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace TranscribeService
}  // namespace Aws