TranscribeStreamingServiceClient.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/transcribestreaming/TranscribeStreamingServiceServiceClientModel.h>
#include <aws/transcribestreaming/TranscribeStreamingService_EXPORTS.h>
 
namespace Aws {
namespace TranscribeStreamingService {
class AWS_TRANSCRIBESTREAMINGSERVICE_API TranscribeStreamingServiceClient
    : public Aws::Client::AWSJsonClient,
      public Aws::Client::ClientWithAsyncTemplateMethods<TranscribeStreamingServiceClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef TranscribeStreamingServiceClientConfiguration ClientConfigurationType;
  typedef TranscribeStreamingServiceEndpointProvider EndpointProviderType;
 
  TranscribeStreamingServiceClient(
      const Aws::TranscribeStreamingService::TranscribeStreamingServiceClientConfiguration& clientConfiguration =
          Aws::TranscribeStreamingService::TranscribeStreamingServiceClientConfiguration(),
      std::shared_ptr<TranscribeStreamingServiceEndpointProviderBase> endpointProvider = nullptr);
 
  TranscribeStreamingServiceClient(
      const Aws::Auth::AWSCredentials& credentials,
      std::shared_ptr<TranscribeStreamingServiceEndpointProviderBase> endpointProvider = nullptr,
      const Aws::TranscribeStreamingService::TranscribeStreamingServiceClientConfiguration& clientConfiguration =
          Aws::TranscribeStreamingService::TranscribeStreamingServiceClientConfiguration());
 
  TranscribeStreamingServiceClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<TranscribeStreamingServiceEndpointProviderBase> endpointProvider = nullptr,
      const Aws::TranscribeStreamingService::TranscribeStreamingServiceClientConfiguration& clientConfiguration =
          Aws::TranscribeStreamingService::TranscribeStreamingServiceClientConfiguration());
 
  /* Legacy constructors due deprecation */
  TranscribeStreamingServiceClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  TranscribeStreamingServiceClient(const Aws::Auth::AWSCredentials& credentials,
                                   const Aws::Client::ClientConfiguration& clientConfiguration);
 
  TranscribeStreamingServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                   const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~TranscribeStreamingServiceClient();
 
  virtual Model::GetMedicalScribeStreamOutcome GetMedicalScribeStream(const Model::GetMedicalScribeStreamRequest& request) const;
 
  template <typename GetMedicalScribeStreamRequestT = Model::GetMedicalScribeStreamRequest>
  Model::GetMedicalScribeStreamOutcomeCallable GetMedicalScribeStreamCallable(const GetMedicalScribeStreamRequestT& request) const {
    return SubmitCallable(&TranscribeStreamingServiceClient::GetMedicalScribeStream, request);
  }
 
  template <typename GetMedicalScribeStreamRequestT = Model::GetMedicalScribeStreamRequest>
  void GetMedicalScribeStreamAsync(const GetMedicalScribeStreamRequestT& request,
                                   const GetMedicalScribeStreamResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TranscribeStreamingServiceClient::GetMedicalScribeStream, request, handler, context);
  }
 
  virtual void StartCallAnalyticsStreamTranscriptionAsync(
      Model::StartCallAnalyticsStreamTranscriptionRequest& request,
      const StartCallAnalyticsStreamTranscriptionStreamReadyHandler& streamReadyHandler,
      const StartCallAnalyticsStreamTranscriptionResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& handlerContext = nullptr) const;
 
  virtual void StartMedicalScribeStreamAsync(Model::StartMedicalScribeStreamRequest& request,
                                             const StartMedicalScribeStreamStreamReadyHandler& streamReadyHandler,
                                             const StartMedicalScribeStreamResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& handlerContext = nullptr) const;
 
  virtual void StartMedicalStreamTranscriptionAsync(
      Model::StartMedicalStreamTranscriptionRequest& request, const StartMedicalStreamTranscriptionStreamReadyHandler& streamReadyHandler,
      const StartMedicalStreamTranscriptionResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& handlerContext = nullptr) const;
 
  virtual void StartStreamTranscriptionAsync(Model::StartStreamTranscriptionRequest& request,
                                             const StartStreamTranscriptionStreamReadyHandler& streamReadyHandler,
                                             const StartStreamTranscriptionResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& handlerContext = nullptr) const;
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<TranscribeStreamingServiceEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<TranscribeStreamingServiceClient>;
  void init(const TranscribeStreamingServiceClientConfiguration& clientConfiguration);
 
  TranscribeStreamingServiceClientConfiguration m_clientConfiguration;
  std::shared_ptr<TranscribeStreamingServiceEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace TranscribeStreamingService
}  // namespace Aws