IvsrealtimeClient.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/ivs-realtime/IvsrealtimePaginationBase.h>
#include <aws/ivs-realtime/IvsrealtimeServiceClientModel.h>
#include <aws/ivs-realtime/Ivsrealtime_EXPORTS.h>
 
namespace Aws {
namespace ivsrealtime {
class AWS_IVSREALTIME_API IvsrealtimeClient : public Aws::Client::AWSJsonClient,
                                              public Aws::Client::ClientWithAsyncTemplateMethods<IvsrealtimeClient>,
                                              public IvsrealtimePaginationBase<IvsrealtimeClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef IvsrealtimeClientConfiguration ClientConfigurationType;
  typedef IvsrealtimeEndpointProvider EndpointProviderType;
 
  IvsrealtimeClient(
      const Aws::ivsrealtime::IvsrealtimeClientConfiguration& clientConfiguration = Aws::ivsrealtime::IvsrealtimeClientConfiguration(),
      std::shared_ptr<IvsrealtimeEndpointProviderBase> endpointProvider = nullptr);
 
  IvsrealtimeClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<IvsrealtimeEndpointProviderBase> endpointProvider = nullptr,
      const Aws::ivsrealtime::IvsrealtimeClientConfiguration& clientConfiguration = Aws::ivsrealtime::IvsrealtimeClientConfiguration());
 
  IvsrealtimeClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<IvsrealtimeEndpointProviderBase> endpointProvider = nullptr,
      const Aws::ivsrealtime::IvsrealtimeClientConfiguration& clientConfiguration = Aws::ivsrealtime::IvsrealtimeClientConfiguration());
 
  /* Legacy constructors due deprecation */
  IvsrealtimeClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  IvsrealtimeClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  IvsrealtimeClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                    const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~IvsrealtimeClient();
 
  virtual Model::CreateEncoderConfigurationOutcome CreateEncoderConfiguration(
      const Model::CreateEncoderConfigurationRequest& request = {}) const;
 
  template <typename CreateEncoderConfigurationRequestT = Model::CreateEncoderConfigurationRequest>
  Model::CreateEncoderConfigurationOutcomeCallable CreateEncoderConfigurationCallable(
      const CreateEncoderConfigurationRequestT& request = {}) const {
    return SubmitCallable(&IvsrealtimeClient::CreateEncoderConfiguration, request);
  }
 
  template <typename CreateEncoderConfigurationRequestT = Model::CreateEncoderConfigurationRequest>
  void CreateEncoderConfigurationAsync(const CreateEncoderConfigurationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const CreateEncoderConfigurationRequestT& request = {}) const {
    return SubmitAsync(&IvsrealtimeClient::CreateEncoderConfiguration, request, handler, context);
  }
 
  virtual Model::CreateIngestConfigurationOutcome CreateIngestConfiguration(const Model::CreateIngestConfigurationRequest& request) const;
 
  template <typename CreateIngestConfigurationRequestT = Model::CreateIngestConfigurationRequest>
  Model::CreateIngestConfigurationOutcomeCallable CreateIngestConfigurationCallable(
      const CreateIngestConfigurationRequestT& request) const {
    return SubmitCallable(&IvsrealtimeClient::CreateIngestConfiguration, request);
  }
 
  template <typename CreateIngestConfigurationRequestT = Model::CreateIngestConfigurationRequest>
  void CreateIngestConfigurationAsync(const CreateIngestConfigurationRequestT& request,
                                      const CreateIngestConfigurationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IvsrealtimeClient::CreateIngestConfiguration, request, handler, context);
  }
 
  virtual Model::CreateParticipantTokenOutcome CreateParticipantToken(const Model::CreateParticipantTokenRequest& request) const;
 
  template <typename CreateParticipantTokenRequestT = Model::CreateParticipantTokenRequest>
  Model::CreateParticipantTokenOutcomeCallable CreateParticipantTokenCallable(const CreateParticipantTokenRequestT& request) const {
    return SubmitCallable(&IvsrealtimeClient::CreateParticipantToken, request);
  }
 
  template <typename CreateParticipantTokenRequestT = Model::CreateParticipantTokenRequest>
  void CreateParticipantTokenAsync(const CreateParticipantTokenRequestT& request,
                                   const CreateParticipantTokenResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IvsrealtimeClient::CreateParticipantToken, request, handler, context);
  }
 
  virtual Model::CreateStageOutcome CreateStage(const Model::CreateStageRequest& request = {}) const;
 
  template <typename CreateStageRequestT = Model::CreateStageRequest>
  Model::CreateStageOutcomeCallable CreateStageCallable(const CreateStageRequestT& request = {}) const {
    return SubmitCallable(&IvsrealtimeClient::CreateStage, request);
  }
 
  template <typename CreateStageRequestT = Model::CreateStageRequest>
  void CreateStageAsync(const CreateStageResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const CreateStageRequestT& request = {}) const {
    return SubmitAsync(&IvsrealtimeClient::CreateStage, request, handler, context);
  }
 
  virtual Model::CreateStorageConfigurationOutcome CreateStorageConfiguration(
      const Model::CreateStorageConfigurationRequest& request) const;
 
  template <typename CreateStorageConfigurationRequestT = Model::CreateStorageConfigurationRequest>
  Model::CreateStorageConfigurationOutcomeCallable CreateStorageConfigurationCallable(
      const CreateStorageConfigurationRequestT& request) const {
    return SubmitCallable(&IvsrealtimeClient::CreateStorageConfiguration, request);
  }
 
  template <typename CreateStorageConfigurationRequestT = Model::CreateStorageConfigurationRequest>
  void CreateStorageConfigurationAsync(const CreateStorageConfigurationRequestT& request,
                                       const CreateStorageConfigurationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IvsrealtimeClient::CreateStorageConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteEncoderConfigurationOutcome DeleteEncoderConfiguration(
      const Model::DeleteEncoderConfigurationRequest& request) const;
 
  template <typename DeleteEncoderConfigurationRequestT = Model::DeleteEncoderConfigurationRequest>
  Model::DeleteEncoderConfigurationOutcomeCallable DeleteEncoderConfigurationCallable(
      const DeleteEncoderConfigurationRequestT& request) const {
    return SubmitCallable(&IvsrealtimeClient::DeleteEncoderConfiguration, request);
  }
 
  template <typename DeleteEncoderConfigurationRequestT = Model::DeleteEncoderConfigurationRequest>
  void DeleteEncoderConfigurationAsync(const DeleteEncoderConfigurationRequestT& request,
                                       const DeleteEncoderConfigurationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IvsrealtimeClient::DeleteEncoderConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteIngestConfigurationOutcome DeleteIngestConfiguration(const Model::DeleteIngestConfigurationRequest& request) const;
 
  template <typename DeleteIngestConfigurationRequestT = Model::DeleteIngestConfigurationRequest>
  Model::DeleteIngestConfigurationOutcomeCallable DeleteIngestConfigurationCallable(
      const DeleteIngestConfigurationRequestT& request) const {
    return SubmitCallable(&IvsrealtimeClient::DeleteIngestConfiguration, request);
  }
 
  template <typename DeleteIngestConfigurationRequestT = Model::DeleteIngestConfigurationRequest>
  void DeleteIngestConfigurationAsync(const DeleteIngestConfigurationRequestT& request,
                                      const DeleteIngestConfigurationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IvsrealtimeClient::DeleteIngestConfiguration, request, handler, context);
  }
 
  virtual Model::DeletePublicKeyOutcome DeletePublicKey(const Model::DeletePublicKeyRequest& request) const;
 
  template <typename DeletePublicKeyRequestT = Model::DeletePublicKeyRequest>
  Model::DeletePublicKeyOutcomeCallable DeletePublicKeyCallable(const DeletePublicKeyRequestT& request) const {
    return SubmitCallable(&IvsrealtimeClient::DeletePublicKey, request);
  }
 
  template <typename DeletePublicKeyRequestT = Model::DeletePublicKeyRequest>
  void DeletePublicKeyAsync(const DeletePublicKeyRequestT& request, const DeletePublicKeyResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IvsrealtimeClient::DeletePublicKey, request, handler, context);
  }
 
  virtual Model::DeleteStageOutcome DeleteStage(const Model::DeleteStageRequest& request) const;
 
  template <typename DeleteStageRequestT = Model::DeleteStageRequest>
  Model::DeleteStageOutcomeCallable DeleteStageCallable(const DeleteStageRequestT& request) const {
    return SubmitCallable(&IvsrealtimeClient::DeleteStage, request);
  }
 
  template <typename DeleteStageRequestT = Model::DeleteStageRequest>
  void DeleteStageAsync(const DeleteStageRequestT& request, const DeleteStageResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IvsrealtimeClient::DeleteStage, request, handler, context);
  }
 
  virtual Model::DeleteStorageConfigurationOutcome DeleteStorageConfiguration(
      const Model::DeleteStorageConfigurationRequest& request) const;
 
  template <typename DeleteStorageConfigurationRequestT = Model::DeleteStorageConfigurationRequest>
  Model::DeleteStorageConfigurationOutcomeCallable DeleteStorageConfigurationCallable(
      const DeleteStorageConfigurationRequestT& request) const {
    return SubmitCallable(&IvsrealtimeClient::DeleteStorageConfiguration, request);
  }
 
  template <typename DeleteStorageConfigurationRequestT = Model::DeleteStorageConfigurationRequest>
  void DeleteStorageConfigurationAsync(const DeleteStorageConfigurationRequestT& request,
                                       const DeleteStorageConfigurationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IvsrealtimeClient::DeleteStorageConfiguration, request, handler, context);
  }
 
  virtual Model::DisconnectParticipantOutcome DisconnectParticipant(const Model::DisconnectParticipantRequest& request) const;
 
  template <typename DisconnectParticipantRequestT = Model::DisconnectParticipantRequest>
  Model::DisconnectParticipantOutcomeCallable DisconnectParticipantCallable(const DisconnectParticipantRequestT& request) const {
    return SubmitCallable(&IvsrealtimeClient::DisconnectParticipant, request);
  }
 
  template <typename DisconnectParticipantRequestT = Model::DisconnectParticipantRequest>
  void DisconnectParticipantAsync(const DisconnectParticipantRequestT& request, const DisconnectParticipantResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IvsrealtimeClient::DisconnectParticipant, request, handler, context);
  }
 
  virtual Model::GetCompositionOutcome GetComposition(const Model::GetCompositionRequest& request) const;
 
  template <typename GetCompositionRequestT = Model::GetCompositionRequest>
  Model::GetCompositionOutcomeCallable GetCompositionCallable(const GetCompositionRequestT& request) const {
    return SubmitCallable(&IvsrealtimeClient::GetComposition, request);
  }
 
  template <typename GetCompositionRequestT = Model::GetCompositionRequest>
  void GetCompositionAsync(const GetCompositionRequestT& request, const GetCompositionResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IvsrealtimeClient::GetComposition, request, handler, context);
  }
 
  virtual Model::GetEncoderConfigurationOutcome GetEncoderConfiguration(const Model::GetEncoderConfigurationRequest& request) const;
 
  template <typename GetEncoderConfigurationRequestT = Model::GetEncoderConfigurationRequest>
  Model::GetEncoderConfigurationOutcomeCallable GetEncoderConfigurationCallable(const GetEncoderConfigurationRequestT& request) const {
    return SubmitCallable(&IvsrealtimeClient::GetEncoderConfiguration, request);
  }
 
  template <typename GetEncoderConfigurationRequestT = Model::GetEncoderConfigurationRequest>
  void GetEncoderConfigurationAsync(const GetEncoderConfigurationRequestT& request,
                                    const GetEncoderConfigurationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IvsrealtimeClient::GetEncoderConfiguration, request, handler, context);
  }
 
  virtual Model::GetIngestConfigurationOutcome GetIngestConfiguration(const Model::GetIngestConfigurationRequest& request) const;
 
  template <typename GetIngestConfigurationRequestT = Model::GetIngestConfigurationRequest>
  Model::GetIngestConfigurationOutcomeCallable GetIngestConfigurationCallable(const GetIngestConfigurationRequestT& request) const {
    return SubmitCallable(&IvsrealtimeClient::GetIngestConfiguration, request);
  }
 
  template <typename GetIngestConfigurationRequestT = Model::GetIngestConfigurationRequest>
  void GetIngestConfigurationAsync(const GetIngestConfigurationRequestT& request,
                                   const GetIngestConfigurationResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IvsrealtimeClient::GetIngestConfiguration, request, handler, context);
  }
 
  virtual Model::GetParticipantOutcome GetParticipant(const Model::GetParticipantRequest& request) const;
 
  template <typename GetParticipantRequestT = Model::GetParticipantRequest>
  Model::GetParticipantOutcomeCallable GetParticipantCallable(const GetParticipantRequestT& request) const {
    return SubmitCallable(&IvsrealtimeClient::GetParticipant, request);
  }
 
  template <typename GetParticipantRequestT = Model::GetParticipantRequest>
  void GetParticipantAsync(const GetParticipantRequestT& request, const GetParticipantResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IvsrealtimeClient::GetParticipant, request, handler, context);
  }
 
  virtual Model::GetPublicKeyOutcome GetPublicKey(const Model::GetPublicKeyRequest& request) const;
 
  template <typename GetPublicKeyRequestT = Model::GetPublicKeyRequest>
  Model::GetPublicKeyOutcomeCallable GetPublicKeyCallable(const GetPublicKeyRequestT& request) const {
    return SubmitCallable(&IvsrealtimeClient::GetPublicKey, request);
  }
 
  template <typename GetPublicKeyRequestT = Model::GetPublicKeyRequest>
  void GetPublicKeyAsync(const GetPublicKeyRequestT& request, const GetPublicKeyResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IvsrealtimeClient::GetPublicKey, request, handler, context);
  }
 
  virtual Model::GetStageOutcome GetStage(const Model::GetStageRequest& request) const;
 
  template <typename GetStageRequestT = Model::GetStageRequest>
  Model::GetStageOutcomeCallable GetStageCallable(const GetStageRequestT& request) const {
    return SubmitCallable(&IvsrealtimeClient::GetStage, request);
  }
 
  template <typename GetStageRequestT = Model::GetStageRequest>
  void GetStageAsync(const GetStageRequestT& request, const GetStageResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IvsrealtimeClient::GetStage, request, handler, context);
  }
 
  virtual Model::GetStageSessionOutcome GetStageSession(const Model::GetStageSessionRequest& request) const;
 
  template <typename GetStageSessionRequestT = Model::GetStageSessionRequest>
  Model::GetStageSessionOutcomeCallable GetStageSessionCallable(const GetStageSessionRequestT& request) const {
    return SubmitCallable(&IvsrealtimeClient::GetStageSession, request);
  }
 
  template <typename GetStageSessionRequestT = Model::GetStageSessionRequest>
  void GetStageSessionAsync(const GetStageSessionRequestT& request, const GetStageSessionResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IvsrealtimeClient::GetStageSession, request, handler, context);
  }
 
  virtual Model::GetStorageConfigurationOutcome GetStorageConfiguration(const Model::GetStorageConfigurationRequest& request) const;
 
  template <typename GetStorageConfigurationRequestT = Model::GetStorageConfigurationRequest>
  Model::GetStorageConfigurationOutcomeCallable GetStorageConfigurationCallable(const GetStorageConfigurationRequestT& request) const {
    return SubmitCallable(&IvsrealtimeClient::GetStorageConfiguration, request);
  }
 
  template <typename GetStorageConfigurationRequestT = Model::GetStorageConfigurationRequest>
  void GetStorageConfigurationAsync(const GetStorageConfigurationRequestT& request,
                                    const GetStorageConfigurationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IvsrealtimeClient::GetStorageConfiguration, request, handler, context);
  }
 
  virtual Model::ImportPublicKeyOutcome ImportPublicKey(const Model::ImportPublicKeyRequest& request) const;
 
  template <typename ImportPublicKeyRequestT = Model::ImportPublicKeyRequest>
  Model::ImportPublicKeyOutcomeCallable ImportPublicKeyCallable(const ImportPublicKeyRequestT& request) const {
    return SubmitCallable(&IvsrealtimeClient::ImportPublicKey, request);
  }
 
  template <typename ImportPublicKeyRequestT = Model::ImportPublicKeyRequest>
  void ImportPublicKeyAsync(const ImportPublicKeyRequestT& request, const ImportPublicKeyResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IvsrealtimeClient::ImportPublicKey, request, handler, context);
  }
 
  virtual Model::ListCompositionsOutcome ListCompositions(const Model::ListCompositionsRequest& request = {}) const;
 
  template <typename ListCompositionsRequestT = Model::ListCompositionsRequest>
  Model::ListCompositionsOutcomeCallable ListCompositionsCallable(const ListCompositionsRequestT& request = {}) const {
    return SubmitCallable(&IvsrealtimeClient::ListCompositions, request);
  }
 
  template <typename ListCompositionsRequestT = Model::ListCompositionsRequest>
  void ListCompositionsAsync(const ListCompositionsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListCompositionsRequestT& request = {}) const {
    return SubmitAsync(&IvsrealtimeClient::ListCompositions, request, handler, context);
  }
 
  virtual Model::ListEncoderConfigurationsOutcome ListEncoderConfigurations(
      const Model::ListEncoderConfigurationsRequest& request = {}) const;
 
  template <typename ListEncoderConfigurationsRequestT = Model::ListEncoderConfigurationsRequest>
  Model::ListEncoderConfigurationsOutcomeCallable ListEncoderConfigurationsCallable(
      const ListEncoderConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&IvsrealtimeClient::ListEncoderConfigurations, request);
  }
 
  template <typename ListEncoderConfigurationsRequestT = Model::ListEncoderConfigurationsRequest>
  void ListEncoderConfigurationsAsync(const ListEncoderConfigurationsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ListEncoderConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&IvsrealtimeClient::ListEncoderConfigurations, request, handler, context);
  }
 
  virtual Model::ListIngestConfigurationsOutcome ListIngestConfigurations(const Model::ListIngestConfigurationsRequest& request = {}) const;
 
  template <typename ListIngestConfigurationsRequestT = Model::ListIngestConfigurationsRequest>
  Model::ListIngestConfigurationsOutcomeCallable ListIngestConfigurationsCallable(
      const ListIngestConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&IvsrealtimeClient::ListIngestConfigurations, request);
  }
 
  template <typename ListIngestConfigurationsRequestT = Model::ListIngestConfigurationsRequest>
  void ListIngestConfigurationsAsync(const ListIngestConfigurationsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const ListIngestConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&IvsrealtimeClient::ListIngestConfigurations, request, handler, context);
  }
 
  virtual Model::ListParticipantEventsOutcome ListParticipantEvents(const Model::ListParticipantEventsRequest& request) const;
 
  template <typename ListParticipantEventsRequestT = Model::ListParticipantEventsRequest>
  Model::ListParticipantEventsOutcomeCallable ListParticipantEventsCallable(const ListParticipantEventsRequestT& request) const {
    return SubmitCallable(&IvsrealtimeClient::ListParticipantEvents, request);
  }
 
  template <typename ListParticipantEventsRequestT = Model::ListParticipantEventsRequest>
  void ListParticipantEventsAsync(const ListParticipantEventsRequestT& request, const ListParticipantEventsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IvsrealtimeClient::ListParticipantEvents, request, handler, context);
  }
 
  virtual Model::ListParticipantReplicasOutcome ListParticipantReplicas(const Model::ListParticipantReplicasRequest& request) const;
 
  template <typename ListParticipantReplicasRequestT = Model::ListParticipantReplicasRequest>
  Model::ListParticipantReplicasOutcomeCallable ListParticipantReplicasCallable(const ListParticipantReplicasRequestT& request) const {
    return SubmitCallable(&IvsrealtimeClient::ListParticipantReplicas, request);
  }
 
  template <typename ListParticipantReplicasRequestT = Model::ListParticipantReplicasRequest>
  void ListParticipantReplicasAsync(const ListParticipantReplicasRequestT& request,
                                    const ListParticipantReplicasResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IvsrealtimeClient::ListParticipantReplicas, request, handler, context);
  }
 
  virtual Model::ListParticipantsOutcome ListParticipants(const Model::ListParticipantsRequest& request) const;
 
  template <typename ListParticipantsRequestT = Model::ListParticipantsRequest>
  Model::ListParticipantsOutcomeCallable ListParticipantsCallable(const ListParticipantsRequestT& request) const {
    return SubmitCallable(&IvsrealtimeClient::ListParticipants, request);
  }
 
  template <typename ListParticipantsRequestT = Model::ListParticipantsRequest>
  void ListParticipantsAsync(const ListParticipantsRequestT& request, const ListParticipantsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IvsrealtimeClient::ListParticipants, request, handler, context);
  }
 
  virtual Model::ListPublicKeysOutcome ListPublicKeys(const Model::ListPublicKeysRequest& request = {}) const;
 
  template <typename ListPublicKeysRequestT = Model::ListPublicKeysRequest>
  Model::ListPublicKeysOutcomeCallable ListPublicKeysCallable(const ListPublicKeysRequestT& request = {}) const {
    return SubmitCallable(&IvsrealtimeClient::ListPublicKeys, request);
  }
 
  template <typename ListPublicKeysRequestT = Model::ListPublicKeysRequest>
  void ListPublicKeysAsync(const ListPublicKeysResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListPublicKeysRequestT& request = {}) const {
    return SubmitAsync(&IvsrealtimeClient::ListPublicKeys, request, handler, context);
  }
 
  virtual Model::ListStageSessionsOutcome ListStageSessions(const Model::ListStageSessionsRequest& request) const;
 
  template <typename ListStageSessionsRequestT = Model::ListStageSessionsRequest>
  Model::ListStageSessionsOutcomeCallable ListStageSessionsCallable(const ListStageSessionsRequestT& request) const {
    return SubmitCallable(&IvsrealtimeClient::ListStageSessions, request);
  }
 
  template <typename ListStageSessionsRequestT = Model::ListStageSessionsRequest>
  void ListStageSessionsAsync(const ListStageSessionsRequestT& request, const ListStageSessionsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IvsrealtimeClient::ListStageSessions, request, handler, context);
  }
 
  virtual Model::ListStagesOutcome ListStages(const Model::ListStagesRequest& request = {}) const;
 
  template <typename ListStagesRequestT = Model::ListStagesRequest>
  Model::ListStagesOutcomeCallable ListStagesCallable(const ListStagesRequestT& request = {}) const {
    return SubmitCallable(&IvsrealtimeClient::ListStages, request);
  }
 
  template <typename ListStagesRequestT = Model::ListStagesRequest>
  void ListStagesAsync(const ListStagesResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                       const ListStagesRequestT& request = {}) const {
    return SubmitAsync(&IvsrealtimeClient::ListStages, request, handler, context);
  }
 
  virtual Model::ListStorageConfigurationsOutcome ListStorageConfigurations(
      const Model::ListStorageConfigurationsRequest& request = {}) const;
 
  template <typename ListStorageConfigurationsRequestT = Model::ListStorageConfigurationsRequest>
  Model::ListStorageConfigurationsOutcomeCallable ListStorageConfigurationsCallable(
      const ListStorageConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&IvsrealtimeClient::ListStorageConfigurations, request);
  }
 
  template <typename ListStorageConfigurationsRequestT = Model::ListStorageConfigurationsRequest>
  void ListStorageConfigurationsAsync(const ListStorageConfigurationsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ListStorageConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&IvsrealtimeClient::ListStorageConfigurations, 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(&IvsrealtimeClient::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(&IvsrealtimeClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::StartCompositionOutcome StartComposition(const Model::StartCompositionRequest& request) const;
 
  template <typename StartCompositionRequestT = Model::StartCompositionRequest>
  Model::StartCompositionOutcomeCallable StartCompositionCallable(const StartCompositionRequestT& request) const {
    return SubmitCallable(&IvsrealtimeClient::StartComposition, request);
  }
 
  template <typename StartCompositionRequestT = Model::StartCompositionRequest>
  void StartCompositionAsync(const StartCompositionRequestT& request, const StartCompositionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IvsrealtimeClient::StartComposition, request, handler, context);
  }
 
  virtual Model::StartParticipantReplicationOutcome StartParticipantReplication(
      const Model::StartParticipantReplicationRequest& request) const;
 
  template <typename StartParticipantReplicationRequestT = Model::StartParticipantReplicationRequest>
  Model::StartParticipantReplicationOutcomeCallable StartParticipantReplicationCallable(
      const StartParticipantReplicationRequestT& request) const {
    return SubmitCallable(&IvsrealtimeClient::StartParticipantReplication, request);
  }
 
  template <typename StartParticipantReplicationRequestT = Model::StartParticipantReplicationRequest>
  void StartParticipantReplicationAsync(const StartParticipantReplicationRequestT& request,
                                        const StartParticipantReplicationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IvsrealtimeClient::StartParticipantReplication, request, handler, context);
  }
 
  virtual Model::StopCompositionOutcome StopComposition(const Model::StopCompositionRequest& request) const;
 
  template <typename StopCompositionRequestT = Model::StopCompositionRequest>
  Model::StopCompositionOutcomeCallable StopCompositionCallable(const StopCompositionRequestT& request) const {
    return SubmitCallable(&IvsrealtimeClient::StopComposition, request);
  }
 
  template <typename StopCompositionRequestT = Model::StopCompositionRequest>
  void StopCompositionAsync(const StopCompositionRequestT& request, const StopCompositionResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IvsrealtimeClient::StopComposition, request, handler, context);
  }
 
  virtual Model::StopParticipantReplicationOutcome StopParticipantReplication(
      const Model::StopParticipantReplicationRequest& request) const;
 
  template <typename StopParticipantReplicationRequestT = Model::StopParticipantReplicationRequest>
  Model::StopParticipantReplicationOutcomeCallable StopParticipantReplicationCallable(
      const StopParticipantReplicationRequestT& request) const {
    return SubmitCallable(&IvsrealtimeClient::StopParticipantReplication, request);
  }
 
  template <typename StopParticipantReplicationRequestT = Model::StopParticipantReplicationRequest>
  void StopParticipantReplicationAsync(const StopParticipantReplicationRequestT& request,
                                       const StopParticipantReplicationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IvsrealtimeClient::StopParticipantReplication, 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(&IvsrealtimeClient::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(&IvsrealtimeClient::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(&IvsrealtimeClient::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(&IvsrealtimeClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateIngestConfigurationOutcome UpdateIngestConfiguration(const Model::UpdateIngestConfigurationRequest& request) const;
 
  template <typename UpdateIngestConfigurationRequestT = Model::UpdateIngestConfigurationRequest>
  Model::UpdateIngestConfigurationOutcomeCallable UpdateIngestConfigurationCallable(
      const UpdateIngestConfigurationRequestT& request) const {
    return SubmitCallable(&IvsrealtimeClient::UpdateIngestConfiguration, request);
  }
 
  template <typename UpdateIngestConfigurationRequestT = Model::UpdateIngestConfigurationRequest>
  void UpdateIngestConfigurationAsync(const UpdateIngestConfigurationRequestT& request,
                                      const UpdateIngestConfigurationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IvsrealtimeClient::UpdateIngestConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateStageOutcome UpdateStage(const Model::UpdateStageRequest& request) const;
 
  template <typename UpdateStageRequestT = Model::UpdateStageRequest>
  Model::UpdateStageOutcomeCallable UpdateStageCallable(const UpdateStageRequestT& request) const {
    return SubmitCallable(&IvsrealtimeClient::UpdateStage, request);
  }
 
  template <typename UpdateStageRequestT = Model::UpdateStageRequest>
  void UpdateStageAsync(const UpdateStageRequestT& request, const UpdateStageResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IvsrealtimeClient::UpdateStage, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<IvsrealtimeEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<IvsrealtimeClient>;
  void init(const IvsrealtimeClientConfiguration& clientConfiguration);
 
  IvsrealtimeClientConfiguration m_clientConfiguration;
  std::shared_ptr<IvsrealtimeEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace ivsrealtime
}  // namespace Aws