IVSClient.h

 
#pragma once
#include <aws/ivs/IVS_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/IVSServiceClientModel.h>
 
namespace Aws
{
namespace IVS
{
  class AWS_IVS_API IVSClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<IVSClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef IVSClientConfiguration ClientConfigurationType;
      typedef IVSEndpointProvider EndpointProviderType;
 
        IVSClient(const Aws::IVS::IVSClientConfiguration& clientConfiguration = Aws::IVS::IVSClientConfiguration(),
                  std::shared_ptr<IVSEndpointProviderBase> endpointProvider = nullptr);
 
        IVSClient(const Aws::Auth::AWSCredentials& credentials,
                  std::shared_ptr<IVSEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::IVS::IVSClientConfiguration& clientConfiguration = Aws::IVS::IVSClientConfiguration());
 
        IVSClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<IVSEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::IVS::IVSClientConfiguration& clientConfiguration = Aws::IVS::IVSClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        IVSClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        IVSClient(const Aws::Auth::AWSCredentials& credentials,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        IVSClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~IVSClient();
 
        virtual Model::BatchGetChannelOutcome BatchGetChannel(const Model::BatchGetChannelRequest& request) const;
 
        template<typename BatchGetChannelRequestT = Model::BatchGetChannelRequest>
        Model::BatchGetChannelOutcomeCallable BatchGetChannelCallable(const BatchGetChannelRequestT& request) const
        {
            return SubmitCallable(&IVSClient::BatchGetChannel, request);
        }
 
        template<typename BatchGetChannelRequestT = Model::BatchGetChannelRequest>
        void BatchGetChannelAsync(const BatchGetChannelRequestT& request, const BatchGetChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IVSClient::BatchGetChannel, request, handler, context);
        }
 
        virtual Model::BatchGetStreamKeyOutcome BatchGetStreamKey(const Model::BatchGetStreamKeyRequest& request) const;
 
        template<typename BatchGetStreamKeyRequestT = Model::BatchGetStreamKeyRequest>
        Model::BatchGetStreamKeyOutcomeCallable BatchGetStreamKeyCallable(const BatchGetStreamKeyRequestT& request) const
        {
            return SubmitCallable(&IVSClient::BatchGetStreamKey, request);
        }
 
        template<typename BatchGetStreamKeyRequestT = Model::BatchGetStreamKeyRequest>
        void BatchGetStreamKeyAsync(const BatchGetStreamKeyRequestT& request, const BatchGetStreamKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IVSClient::BatchGetStreamKey, request, handler, context);
        }
 
        virtual Model::BatchStartViewerSessionRevocationOutcome BatchStartViewerSessionRevocation(const Model::BatchStartViewerSessionRevocationRequest& request) const;
 
        template<typename BatchStartViewerSessionRevocationRequestT = Model::BatchStartViewerSessionRevocationRequest>
        Model::BatchStartViewerSessionRevocationOutcomeCallable BatchStartViewerSessionRevocationCallable(const BatchStartViewerSessionRevocationRequestT& request) const
        {
            return SubmitCallable(&IVSClient::BatchStartViewerSessionRevocation, request);
        }
 
        template<typename BatchStartViewerSessionRevocationRequestT = Model::BatchStartViewerSessionRevocationRequest>
        void BatchStartViewerSessionRevocationAsync(const BatchStartViewerSessionRevocationRequestT& request, const BatchStartViewerSessionRevocationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IVSClient::BatchStartViewerSessionRevocation, request, handler, context);
        }
 
        virtual Model::CreateChannelOutcome CreateChannel(const Model::CreateChannelRequest& request = {}) const;
 
        template<typename CreateChannelRequestT = Model::CreateChannelRequest>
        Model::CreateChannelOutcomeCallable CreateChannelCallable(const CreateChannelRequestT& request = {}) const
        {
            return SubmitCallable(&IVSClient::CreateChannel, request);
        }
 
        template<typename CreateChannelRequestT = Model::CreateChannelRequest>
        void CreateChannelAsync(const CreateChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateChannelRequestT& request = {}) const
        {
            return SubmitAsync(&IVSClient::CreateChannel, request, handler, context);
        }
 
        virtual Model::CreatePlaybackRestrictionPolicyOutcome CreatePlaybackRestrictionPolicy(const Model::CreatePlaybackRestrictionPolicyRequest& request = {}) const;
 
        template<typename CreatePlaybackRestrictionPolicyRequestT = Model::CreatePlaybackRestrictionPolicyRequest>
        Model::CreatePlaybackRestrictionPolicyOutcomeCallable CreatePlaybackRestrictionPolicyCallable(const CreatePlaybackRestrictionPolicyRequestT& request = {}) const
        {
            return SubmitCallable(&IVSClient::CreatePlaybackRestrictionPolicy, request);
        }
 
        template<typename CreatePlaybackRestrictionPolicyRequestT = Model::CreatePlaybackRestrictionPolicyRequest>
        void CreatePlaybackRestrictionPolicyAsync(const CreatePlaybackRestrictionPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreatePlaybackRestrictionPolicyRequestT& request = {}) const
        {
            return SubmitAsync(&IVSClient::CreatePlaybackRestrictionPolicy, request, handler, context);
        }
 
        virtual Model::CreateRecordingConfigurationOutcome CreateRecordingConfiguration(const Model::CreateRecordingConfigurationRequest& request) const;
 
        template<typename CreateRecordingConfigurationRequestT = Model::CreateRecordingConfigurationRequest>
        Model::CreateRecordingConfigurationOutcomeCallable CreateRecordingConfigurationCallable(const CreateRecordingConfigurationRequestT& request) const
        {
            return SubmitCallable(&IVSClient::CreateRecordingConfiguration, request);
        }
 
        template<typename CreateRecordingConfigurationRequestT = Model::CreateRecordingConfigurationRequest>
        void CreateRecordingConfigurationAsync(const CreateRecordingConfigurationRequestT& request, const CreateRecordingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IVSClient::CreateRecordingConfiguration, request, handler, context);
        }
 
        virtual Model::CreateStreamKeyOutcome CreateStreamKey(const Model::CreateStreamKeyRequest& request) const;
 
        template<typename CreateStreamKeyRequestT = Model::CreateStreamKeyRequest>
        Model::CreateStreamKeyOutcomeCallable CreateStreamKeyCallable(const CreateStreamKeyRequestT& request) const
        {
            return SubmitCallable(&IVSClient::CreateStreamKey, request);
        }
 
        template<typename CreateStreamKeyRequestT = Model::CreateStreamKeyRequest>
        void CreateStreamKeyAsync(const CreateStreamKeyRequestT& request, const CreateStreamKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IVSClient::CreateStreamKey, request, handler, context);
        }
 
        virtual Model::DeleteChannelOutcome DeleteChannel(const Model::DeleteChannelRequest& request) const;
 
        template<typename DeleteChannelRequestT = Model::DeleteChannelRequest>
        Model::DeleteChannelOutcomeCallable DeleteChannelCallable(const DeleteChannelRequestT& request) const
        {
            return SubmitCallable(&IVSClient::DeleteChannel, request);
        }
 
        template<typename DeleteChannelRequestT = Model::DeleteChannelRequest>
        void DeleteChannelAsync(const DeleteChannelRequestT& request, const DeleteChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IVSClient::DeleteChannel, request, handler, context);
        }
 
        virtual Model::DeletePlaybackKeyPairOutcome DeletePlaybackKeyPair(const Model::DeletePlaybackKeyPairRequest& request) const;
 
        template<typename DeletePlaybackKeyPairRequestT = Model::DeletePlaybackKeyPairRequest>
        Model::DeletePlaybackKeyPairOutcomeCallable DeletePlaybackKeyPairCallable(const DeletePlaybackKeyPairRequestT& request) const
        {
            return SubmitCallable(&IVSClient::DeletePlaybackKeyPair, request);
        }
 
        template<typename DeletePlaybackKeyPairRequestT = Model::DeletePlaybackKeyPairRequest>
        void DeletePlaybackKeyPairAsync(const DeletePlaybackKeyPairRequestT& request, const DeletePlaybackKeyPairResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IVSClient::DeletePlaybackKeyPair, request, handler, context);
        }
 
        virtual Model::DeletePlaybackRestrictionPolicyOutcome DeletePlaybackRestrictionPolicy(const Model::DeletePlaybackRestrictionPolicyRequest& request) const;
 
        template<typename DeletePlaybackRestrictionPolicyRequestT = Model::DeletePlaybackRestrictionPolicyRequest>
        Model::DeletePlaybackRestrictionPolicyOutcomeCallable DeletePlaybackRestrictionPolicyCallable(const DeletePlaybackRestrictionPolicyRequestT& request) const
        {
            return SubmitCallable(&IVSClient::DeletePlaybackRestrictionPolicy, request);
        }
 
        template<typename DeletePlaybackRestrictionPolicyRequestT = Model::DeletePlaybackRestrictionPolicyRequest>
        void DeletePlaybackRestrictionPolicyAsync(const DeletePlaybackRestrictionPolicyRequestT& request, const DeletePlaybackRestrictionPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IVSClient::DeletePlaybackRestrictionPolicy, request, handler, context);
        }
 
        virtual Model::DeleteRecordingConfigurationOutcome DeleteRecordingConfiguration(const Model::DeleteRecordingConfigurationRequest& request) const;
 
        template<typename DeleteRecordingConfigurationRequestT = Model::DeleteRecordingConfigurationRequest>
        Model::DeleteRecordingConfigurationOutcomeCallable DeleteRecordingConfigurationCallable(const DeleteRecordingConfigurationRequestT& request) const
        {
            return SubmitCallable(&IVSClient::DeleteRecordingConfiguration, request);
        }
 
        template<typename DeleteRecordingConfigurationRequestT = Model::DeleteRecordingConfigurationRequest>
        void DeleteRecordingConfigurationAsync(const DeleteRecordingConfigurationRequestT& request, const DeleteRecordingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IVSClient::DeleteRecordingConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteStreamKeyOutcome DeleteStreamKey(const Model::DeleteStreamKeyRequest& request) const;
 
        template<typename DeleteStreamKeyRequestT = Model::DeleteStreamKeyRequest>
        Model::DeleteStreamKeyOutcomeCallable DeleteStreamKeyCallable(const DeleteStreamKeyRequestT& request) const
        {
            return SubmitCallable(&IVSClient::DeleteStreamKey, request);
        }
 
        template<typename DeleteStreamKeyRequestT = Model::DeleteStreamKeyRequest>
        void DeleteStreamKeyAsync(const DeleteStreamKeyRequestT& request, const DeleteStreamKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IVSClient::DeleteStreamKey, request, handler, context);
        }
 
        virtual Model::GetChannelOutcome GetChannel(const Model::GetChannelRequest& request) const;
 
        template<typename GetChannelRequestT = Model::GetChannelRequest>
        Model::GetChannelOutcomeCallable GetChannelCallable(const GetChannelRequestT& request) const
        {
            return SubmitCallable(&IVSClient::GetChannel, request);
        }
 
        template<typename GetChannelRequestT = Model::GetChannelRequest>
        void GetChannelAsync(const GetChannelRequestT& request, const GetChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IVSClient::GetChannel, request, handler, context);
        }
 
        virtual Model::GetPlaybackKeyPairOutcome GetPlaybackKeyPair(const Model::GetPlaybackKeyPairRequest& request) const;
 
        template<typename GetPlaybackKeyPairRequestT = Model::GetPlaybackKeyPairRequest>
        Model::GetPlaybackKeyPairOutcomeCallable GetPlaybackKeyPairCallable(const GetPlaybackKeyPairRequestT& request) const
        {
            return SubmitCallable(&IVSClient::GetPlaybackKeyPair, request);
        }
 
        template<typename GetPlaybackKeyPairRequestT = Model::GetPlaybackKeyPairRequest>
        void GetPlaybackKeyPairAsync(const GetPlaybackKeyPairRequestT& request, const GetPlaybackKeyPairResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IVSClient::GetPlaybackKeyPair, request, handler, context);
        }
 
        virtual Model::GetPlaybackRestrictionPolicyOutcome GetPlaybackRestrictionPolicy(const Model::GetPlaybackRestrictionPolicyRequest& request) const;
 
        template<typename GetPlaybackRestrictionPolicyRequestT = Model::GetPlaybackRestrictionPolicyRequest>
        Model::GetPlaybackRestrictionPolicyOutcomeCallable GetPlaybackRestrictionPolicyCallable(const GetPlaybackRestrictionPolicyRequestT& request) const
        {
            return SubmitCallable(&IVSClient::GetPlaybackRestrictionPolicy, request);
        }
 
        template<typename GetPlaybackRestrictionPolicyRequestT = Model::GetPlaybackRestrictionPolicyRequest>
        void GetPlaybackRestrictionPolicyAsync(const GetPlaybackRestrictionPolicyRequestT& request, const GetPlaybackRestrictionPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IVSClient::GetPlaybackRestrictionPolicy, request, handler, context);
        }
 
        virtual Model::GetRecordingConfigurationOutcome GetRecordingConfiguration(const Model::GetRecordingConfigurationRequest& request) const;
 
        template<typename GetRecordingConfigurationRequestT = Model::GetRecordingConfigurationRequest>
        Model::GetRecordingConfigurationOutcomeCallable GetRecordingConfigurationCallable(const GetRecordingConfigurationRequestT& request) const
        {
            return SubmitCallable(&IVSClient::GetRecordingConfiguration, request);
        }
 
        template<typename GetRecordingConfigurationRequestT = Model::GetRecordingConfigurationRequest>
        void GetRecordingConfigurationAsync(const GetRecordingConfigurationRequestT& request, const GetRecordingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IVSClient::GetRecordingConfiguration, request, handler, context);
        }
 
        virtual Model::GetStreamOutcome GetStream(const Model::GetStreamRequest& request) const;
 
        template<typename GetStreamRequestT = Model::GetStreamRequest>
        Model::GetStreamOutcomeCallable GetStreamCallable(const GetStreamRequestT& request) const
        {
            return SubmitCallable(&IVSClient::GetStream, request);
        }
 
        template<typename GetStreamRequestT = Model::GetStreamRequest>
        void GetStreamAsync(const GetStreamRequestT& request, const GetStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IVSClient::GetStream, request, handler, context);
        }
 
        virtual Model::GetStreamKeyOutcome GetStreamKey(const Model::GetStreamKeyRequest& request) const;
 
        template<typename GetStreamKeyRequestT = Model::GetStreamKeyRequest>
        Model::GetStreamKeyOutcomeCallable GetStreamKeyCallable(const GetStreamKeyRequestT& request) const
        {
            return SubmitCallable(&IVSClient::GetStreamKey, request);
        }
 
        template<typename GetStreamKeyRequestT = Model::GetStreamKeyRequest>
        void GetStreamKeyAsync(const GetStreamKeyRequestT& request, const GetStreamKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IVSClient::GetStreamKey, request, handler, context);
        }
 
        virtual Model::GetStreamSessionOutcome GetStreamSession(const Model::GetStreamSessionRequest& request) const;
 
        template<typename GetStreamSessionRequestT = Model::GetStreamSessionRequest>
        Model::GetStreamSessionOutcomeCallable GetStreamSessionCallable(const GetStreamSessionRequestT& request) const
        {
            return SubmitCallable(&IVSClient::GetStreamSession, request);
        }
 
        template<typename GetStreamSessionRequestT = Model::GetStreamSessionRequest>
        void GetStreamSessionAsync(const GetStreamSessionRequestT& request, const GetStreamSessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IVSClient::GetStreamSession, request, handler, context);
        }
 
        virtual Model::ImportPlaybackKeyPairOutcome ImportPlaybackKeyPair(const Model::ImportPlaybackKeyPairRequest& request) const;
 
        template<typename ImportPlaybackKeyPairRequestT = Model::ImportPlaybackKeyPairRequest>
        Model::ImportPlaybackKeyPairOutcomeCallable ImportPlaybackKeyPairCallable(const ImportPlaybackKeyPairRequestT& request) const
        {
            return SubmitCallable(&IVSClient::ImportPlaybackKeyPair, request);
        }
 
        template<typename ImportPlaybackKeyPairRequestT = Model::ImportPlaybackKeyPairRequest>
        void ImportPlaybackKeyPairAsync(const ImportPlaybackKeyPairRequestT& request, const ImportPlaybackKeyPairResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IVSClient::ImportPlaybackKeyPair, request, handler, context);
        }
 
        virtual Model::ListChannelsOutcome ListChannels(const Model::ListChannelsRequest& request = {}) const;
 
        template<typename ListChannelsRequestT = Model::ListChannelsRequest>
        Model::ListChannelsOutcomeCallable ListChannelsCallable(const ListChannelsRequestT& request = {}) const
        {
            return SubmitCallable(&IVSClient::ListChannels, request);
        }
 
        template<typename ListChannelsRequestT = Model::ListChannelsRequest>
        void ListChannelsAsync(const ListChannelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListChannelsRequestT& request = {}) const
        {
            return SubmitAsync(&IVSClient::ListChannels, request, handler, context);
        }
 
        virtual Model::ListPlaybackKeyPairsOutcome ListPlaybackKeyPairs(const Model::ListPlaybackKeyPairsRequest& request = {}) const;
 
        template<typename ListPlaybackKeyPairsRequestT = Model::ListPlaybackKeyPairsRequest>
        Model::ListPlaybackKeyPairsOutcomeCallable ListPlaybackKeyPairsCallable(const ListPlaybackKeyPairsRequestT& request = {}) const
        {
            return SubmitCallable(&IVSClient::ListPlaybackKeyPairs, request);
        }
 
        template<typename ListPlaybackKeyPairsRequestT = Model::ListPlaybackKeyPairsRequest>
        void ListPlaybackKeyPairsAsync(const ListPlaybackKeyPairsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPlaybackKeyPairsRequestT& request = {}) const
        {
            return SubmitAsync(&IVSClient::ListPlaybackKeyPairs, request, handler, context);
        }
 
        virtual Model::ListPlaybackRestrictionPoliciesOutcome ListPlaybackRestrictionPolicies(const Model::ListPlaybackRestrictionPoliciesRequest& request = {}) const;
 
        template<typename ListPlaybackRestrictionPoliciesRequestT = Model::ListPlaybackRestrictionPoliciesRequest>
        Model::ListPlaybackRestrictionPoliciesOutcomeCallable ListPlaybackRestrictionPoliciesCallable(const ListPlaybackRestrictionPoliciesRequestT& request = {}) const
        {
            return SubmitCallable(&IVSClient::ListPlaybackRestrictionPolicies, request);
        }
 
        template<typename ListPlaybackRestrictionPoliciesRequestT = Model::ListPlaybackRestrictionPoliciesRequest>
        void ListPlaybackRestrictionPoliciesAsync(const ListPlaybackRestrictionPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPlaybackRestrictionPoliciesRequestT& request = {}) const
        {
            return SubmitAsync(&IVSClient::ListPlaybackRestrictionPolicies, request, handler, context);
        }
 
        virtual Model::ListRecordingConfigurationsOutcome ListRecordingConfigurations(const Model::ListRecordingConfigurationsRequest& request = {}) const;
 
        template<typename ListRecordingConfigurationsRequestT = Model::ListRecordingConfigurationsRequest>
        Model::ListRecordingConfigurationsOutcomeCallable ListRecordingConfigurationsCallable(const ListRecordingConfigurationsRequestT& request = {}) const
        {
            return SubmitCallable(&IVSClient::ListRecordingConfigurations, request);
        }
 
        template<typename ListRecordingConfigurationsRequestT = Model::ListRecordingConfigurationsRequest>
        void ListRecordingConfigurationsAsync(const ListRecordingConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListRecordingConfigurationsRequestT& request = {}) const
        {
            return SubmitAsync(&IVSClient::ListRecordingConfigurations, request, handler, context);
        }
 
        virtual Model::ListStreamKeysOutcome ListStreamKeys(const Model::ListStreamKeysRequest& request) const;
 
        template<typename ListStreamKeysRequestT = Model::ListStreamKeysRequest>
        Model::ListStreamKeysOutcomeCallable ListStreamKeysCallable(const ListStreamKeysRequestT& request) const
        {
            return SubmitCallable(&IVSClient::ListStreamKeys, request);
        }
 
        template<typename ListStreamKeysRequestT = Model::ListStreamKeysRequest>
        void ListStreamKeysAsync(const ListStreamKeysRequestT& request, const ListStreamKeysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IVSClient::ListStreamKeys, request, handler, context);
        }
 
        virtual Model::ListStreamSessionsOutcome ListStreamSessions(const Model::ListStreamSessionsRequest& request) const;
 
        template<typename ListStreamSessionsRequestT = Model::ListStreamSessionsRequest>
        Model::ListStreamSessionsOutcomeCallable ListStreamSessionsCallable(const ListStreamSessionsRequestT& request) const
        {
            return SubmitCallable(&IVSClient::ListStreamSessions, request);
        }
 
        template<typename ListStreamSessionsRequestT = Model::ListStreamSessionsRequest>
        void ListStreamSessionsAsync(const ListStreamSessionsRequestT& request, const ListStreamSessionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IVSClient::ListStreamSessions, request, handler, context);
        }
 
        virtual Model::ListStreamsOutcome ListStreams(const Model::ListStreamsRequest& request = {}) const;
 
        template<typename ListStreamsRequestT = Model::ListStreamsRequest>
        Model::ListStreamsOutcomeCallable ListStreamsCallable(const ListStreamsRequestT& request = {}) const
        {
            return SubmitCallable(&IVSClient::ListStreams, request);
        }
 
        template<typename ListStreamsRequestT = Model::ListStreamsRequest>
        void ListStreamsAsync(const ListStreamsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListStreamsRequestT& request = {}) const
        {
            return SubmitAsync(&IVSClient::ListStreams, 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(&IVSClient::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(&IVSClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::PutMetadataOutcome PutMetadata(const Model::PutMetadataRequest& request) const;
 
        template<typename PutMetadataRequestT = Model::PutMetadataRequest>
        Model::PutMetadataOutcomeCallable PutMetadataCallable(const PutMetadataRequestT& request) const
        {
            return SubmitCallable(&IVSClient::PutMetadata, request);
        }
 
        template<typename PutMetadataRequestT = Model::PutMetadataRequest>
        void PutMetadataAsync(const PutMetadataRequestT& request, const PutMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IVSClient::PutMetadata, request, handler, context);
        }
 
        virtual Model::StartViewerSessionRevocationOutcome StartViewerSessionRevocation(const Model::StartViewerSessionRevocationRequest& request) const;
 
        template<typename StartViewerSessionRevocationRequestT = Model::StartViewerSessionRevocationRequest>
        Model::StartViewerSessionRevocationOutcomeCallable StartViewerSessionRevocationCallable(const StartViewerSessionRevocationRequestT& request) const
        {
            return SubmitCallable(&IVSClient::StartViewerSessionRevocation, request);
        }
 
        template<typename StartViewerSessionRevocationRequestT = Model::StartViewerSessionRevocationRequest>
        void StartViewerSessionRevocationAsync(const StartViewerSessionRevocationRequestT& request, const StartViewerSessionRevocationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IVSClient::StartViewerSessionRevocation, request, handler, context);
        }
 
        virtual Model::StopStreamOutcome StopStream(const Model::StopStreamRequest& request) const;
 
        template<typename StopStreamRequestT = Model::StopStreamRequest>
        Model::StopStreamOutcomeCallable StopStreamCallable(const StopStreamRequestT& request) const
        {
            return SubmitCallable(&IVSClient::StopStream, request);
        }
 
        template<typename StopStreamRequestT = Model::StopStreamRequest>
        void StopStreamAsync(const StopStreamRequestT& request, const StopStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IVSClient::StopStream, 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(&IVSClient::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(&IVSClient::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(&IVSClient::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(&IVSClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateChannelOutcome UpdateChannel(const Model::UpdateChannelRequest& request) const;
 
        template<typename UpdateChannelRequestT = Model::UpdateChannelRequest>
        Model::UpdateChannelOutcomeCallable UpdateChannelCallable(const UpdateChannelRequestT& request) const
        {
            return SubmitCallable(&IVSClient::UpdateChannel, request);
        }
 
        template<typename UpdateChannelRequestT = Model::UpdateChannelRequest>
        void UpdateChannelAsync(const UpdateChannelRequestT& request, const UpdateChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IVSClient::UpdateChannel, request, handler, context);
        }
 
        virtual Model::UpdatePlaybackRestrictionPolicyOutcome UpdatePlaybackRestrictionPolicy(const Model::UpdatePlaybackRestrictionPolicyRequest& request) const;
 
        template<typename UpdatePlaybackRestrictionPolicyRequestT = Model::UpdatePlaybackRestrictionPolicyRequest>
        Model::UpdatePlaybackRestrictionPolicyOutcomeCallable UpdatePlaybackRestrictionPolicyCallable(const UpdatePlaybackRestrictionPolicyRequestT& request) const
        {
            return SubmitCallable(&IVSClient::UpdatePlaybackRestrictionPolicy, request);
        }
 
        template<typename UpdatePlaybackRestrictionPolicyRequestT = Model::UpdatePlaybackRestrictionPolicyRequest>
        void UpdatePlaybackRestrictionPolicyAsync(const UpdatePlaybackRestrictionPolicyRequestT& request, const UpdatePlaybackRestrictionPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IVSClient::UpdatePlaybackRestrictionPolicy, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<IVSEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<IVSClient>;
      void init(const IVSClientConfiguration& clientConfiguration);
 
      IVSClientConfiguration m_clientConfiguration;
      std::shared_ptr<IVSEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace IVS
} // namespace Aws