IVSClient.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/IVSServiceClientModel.h>
#include <aws/ivs/IVS_EXPORTS.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