IvsrealtimeClient.h

 
#pragma once
#include <aws/ivs-realtime/Ivsrealtime_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/ivs-realtime/IvsrealtimeServiceClientModel.h>
 
namespace Aws
{
namespace ivsrealtime
{
  class AWS_IVSREALTIME_API IvsrealtimeClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      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