KinesisVideoClient.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/kinesisvideo/KinesisVideoPaginationBase.h>
#include <aws/kinesisvideo/KinesisVideoServiceClientModel.h>
#include <aws/kinesisvideo/KinesisVideoWaiter.h>
#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
 
namespace Aws {
namespace KinesisVideo {
class AWS_KINESISVIDEO_API KinesisVideoClient : public Aws::Client::AWSJsonClient,
                                                public Aws::Client::ClientWithAsyncTemplateMethods<KinesisVideoClient>,
                                                public KinesisVideoPaginationBase<KinesisVideoClient>,
                                                public KinesisVideoWaiter<KinesisVideoClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef KinesisVideoClientConfiguration ClientConfigurationType;
  typedef KinesisVideoEndpointProvider EndpointProviderType;
 
  KinesisVideoClient(
      const Aws::KinesisVideo::KinesisVideoClientConfiguration& clientConfiguration = Aws::KinesisVideo::KinesisVideoClientConfiguration(),
      std::shared_ptr<KinesisVideoEndpointProviderBase> endpointProvider = nullptr);
 
  KinesisVideoClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<KinesisVideoEndpointProviderBase> endpointProvider = nullptr,
      const Aws::KinesisVideo::KinesisVideoClientConfiguration& clientConfiguration = Aws::KinesisVideo::KinesisVideoClientConfiguration());
 
  KinesisVideoClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<KinesisVideoEndpointProviderBase> endpointProvider = nullptr,
      const Aws::KinesisVideo::KinesisVideoClientConfiguration& clientConfiguration = Aws::KinesisVideo::KinesisVideoClientConfiguration());
 
  /* Legacy constructors due deprecation */
  KinesisVideoClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  KinesisVideoClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  KinesisVideoClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~KinesisVideoClient();
 
  virtual Model::CreateSignalingChannelOutcome CreateSignalingChannel(const Model::CreateSignalingChannelRequest& request) const;
 
  template <typename CreateSignalingChannelRequestT = Model::CreateSignalingChannelRequest>
  Model::CreateSignalingChannelOutcomeCallable CreateSignalingChannelCallable(const CreateSignalingChannelRequestT& request) const {
    return SubmitCallable(&KinesisVideoClient::CreateSignalingChannel, request);
  }
 
  template <typename CreateSignalingChannelRequestT = Model::CreateSignalingChannelRequest>
  void CreateSignalingChannelAsync(const CreateSignalingChannelRequestT& request,
                                   const CreateSignalingChannelResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisVideoClient::CreateSignalingChannel, request, handler, context);
  }
 
  virtual Model::CreateStreamOutcome CreateStream(const Model::CreateStreamRequest& request) const;
 
  template <typename CreateStreamRequestT = Model::CreateStreamRequest>
  Model::CreateStreamOutcomeCallable CreateStreamCallable(const CreateStreamRequestT& request) const {
    return SubmitCallable(&KinesisVideoClient::CreateStream, request);
  }
 
  template <typename CreateStreamRequestT = Model::CreateStreamRequest>
  void CreateStreamAsync(const CreateStreamRequestT& request, const CreateStreamResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisVideoClient::CreateStream, request, handler, context);
  }
 
  virtual Model::DeleteEdgeConfigurationOutcome DeleteEdgeConfiguration(const Model::DeleteEdgeConfigurationRequest& request = {}) const;
 
  template <typename DeleteEdgeConfigurationRequestT = Model::DeleteEdgeConfigurationRequest>
  Model::DeleteEdgeConfigurationOutcomeCallable DeleteEdgeConfigurationCallable(const DeleteEdgeConfigurationRequestT& request = {}) const {
    return SubmitCallable(&KinesisVideoClient::DeleteEdgeConfiguration, request);
  }
 
  template <typename DeleteEdgeConfigurationRequestT = Model::DeleteEdgeConfigurationRequest>
  void DeleteEdgeConfigurationAsync(const DeleteEdgeConfigurationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const DeleteEdgeConfigurationRequestT& request = {}) const {
    return SubmitAsync(&KinesisVideoClient::DeleteEdgeConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteSignalingChannelOutcome DeleteSignalingChannel(const Model::DeleteSignalingChannelRequest& request) const;
 
  template <typename DeleteSignalingChannelRequestT = Model::DeleteSignalingChannelRequest>
  Model::DeleteSignalingChannelOutcomeCallable DeleteSignalingChannelCallable(const DeleteSignalingChannelRequestT& request) const {
    return SubmitCallable(&KinesisVideoClient::DeleteSignalingChannel, request);
  }
 
  template <typename DeleteSignalingChannelRequestT = Model::DeleteSignalingChannelRequest>
  void DeleteSignalingChannelAsync(const DeleteSignalingChannelRequestT& request,
                                   const DeleteSignalingChannelResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisVideoClient::DeleteSignalingChannel, request, handler, context);
  }
 
  virtual Model::DeleteStreamOutcome DeleteStream(const Model::DeleteStreamRequest& request) const;
 
  template <typename DeleteStreamRequestT = Model::DeleteStreamRequest>
  Model::DeleteStreamOutcomeCallable DeleteStreamCallable(const DeleteStreamRequestT& request) const {
    return SubmitCallable(&KinesisVideoClient::DeleteStream, request);
  }
 
  template <typename DeleteStreamRequestT = Model::DeleteStreamRequest>
  void DeleteStreamAsync(const DeleteStreamRequestT& request, const DeleteStreamResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisVideoClient::DeleteStream, request, handler, context);
  }
 
  virtual Model::DescribeEdgeConfigurationOutcome DescribeEdgeConfiguration(
      const Model::DescribeEdgeConfigurationRequest& request = {}) const;
 
  template <typename DescribeEdgeConfigurationRequestT = Model::DescribeEdgeConfigurationRequest>
  Model::DescribeEdgeConfigurationOutcomeCallable DescribeEdgeConfigurationCallable(
      const DescribeEdgeConfigurationRequestT& request = {}) const {
    return SubmitCallable(&KinesisVideoClient::DescribeEdgeConfiguration, request);
  }
 
  template <typename DescribeEdgeConfigurationRequestT = Model::DescribeEdgeConfigurationRequest>
  void DescribeEdgeConfigurationAsync(const DescribeEdgeConfigurationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const DescribeEdgeConfigurationRequestT& request = {}) const {
    return SubmitAsync(&KinesisVideoClient::DescribeEdgeConfiguration, request, handler, context);
  }
 
  virtual Model::DescribeImageGenerationConfigurationOutcome DescribeImageGenerationConfiguration(
      const Model::DescribeImageGenerationConfigurationRequest& request = {}) const;
 
  template <typename DescribeImageGenerationConfigurationRequestT = Model::DescribeImageGenerationConfigurationRequest>
  Model::DescribeImageGenerationConfigurationOutcomeCallable DescribeImageGenerationConfigurationCallable(
      const DescribeImageGenerationConfigurationRequestT& request = {}) const {
    return SubmitCallable(&KinesisVideoClient::DescribeImageGenerationConfiguration, request);
  }
 
  template <typename DescribeImageGenerationConfigurationRequestT = Model::DescribeImageGenerationConfigurationRequest>
  void DescribeImageGenerationConfigurationAsync(const DescribeImageGenerationConfigurationResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                 const DescribeImageGenerationConfigurationRequestT& request = {}) const {
    return SubmitAsync(&KinesisVideoClient::DescribeImageGenerationConfiguration, request, handler, context);
  }
 
  virtual Model::DescribeMappedResourceConfigurationOutcome DescribeMappedResourceConfiguration(
      const Model::DescribeMappedResourceConfigurationRequest& request = {}) const;
 
  template <typename DescribeMappedResourceConfigurationRequestT = Model::DescribeMappedResourceConfigurationRequest>
  Model::DescribeMappedResourceConfigurationOutcomeCallable DescribeMappedResourceConfigurationCallable(
      const DescribeMappedResourceConfigurationRequestT& request = {}) const {
    return SubmitCallable(&KinesisVideoClient::DescribeMappedResourceConfiguration, request);
  }
 
  template <typename DescribeMappedResourceConfigurationRequestT = Model::DescribeMappedResourceConfigurationRequest>
  void DescribeMappedResourceConfigurationAsync(const DescribeMappedResourceConfigurationResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                const DescribeMappedResourceConfigurationRequestT& request = {}) const {
    return SubmitAsync(&KinesisVideoClient::DescribeMappedResourceConfiguration, request, handler, context);
  }
 
  virtual Model::DescribeMediaStorageConfigurationOutcome DescribeMediaStorageConfiguration(
      const Model::DescribeMediaStorageConfigurationRequest& request = {}) const;
 
  template <typename DescribeMediaStorageConfigurationRequestT = Model::DescribeMediaStorageConfigurationRequest>
  Model::DescribeMediaStorageConfigurationOutcomeCallable DescribeMediaStorageConfigurationCallable(
      const DescribeMediaStorageConfigurationRequestT& request = {}) const {
    return SubmitCallable(&KinesisVideoClient::DescribeMediaStorageConfiguration, request);
  }
 
  template <typename DescribeMediaStorageConfigurationRequestT = Model::DescribeMediaStorageConfigurationRequest>
  void DescribeMediaStorageConfigurationAsync(const DescribeMediaStorageConfigurationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const DescribeMediaStorageConfigurationRequestT& request = {}) const {
    return SubmitAsync(&KinesisVideoClient::DescribeMediaStorageConfiguration, request, handler, context);
  }
 
  virtual Model::DescribeNotificationConfigurationOutcome DescribeNotificationConfiguration(
      const Model::DescribeNotificationConfigurationRequest& request = {}) const;
 
  template <typename DescribeNotificationConfigurationRequestT = Model::DescribeNotificationConfigurationRequest>
  Model::DescribeNotificationConfigurationOutcomeCallable DescribeNotificationConfigurationCallable(
      const DescribeNotificationConfigurationRequestT& request = {}) const {
    return SubmitCallable(&KinesisVideoClient::DescribeNotificationConfiguration, request);
  }
 
  template <typename DescribeNotificationConfigurationRequestT = Model::DescribeNotificationConfigurationRequest>
  void DescribeNotificationConfigurationAsync(const DescribeNotificationConfigurationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const DescribeNotificationConfigurationRequestT& request = {}) const {
    return SubmitAsync(&KinesisVideoClient::DescribeNotificationConfiguration, request, handler, context);
  }
 
  virtual Model::DescribeSignalingChannelOutcome DescribeSignalingChannel(const Model::DescribeSignalingChannelRequest& request = {}) const;
 
  template <typename DescribeSignalingChannelRequestT = Model::DescribeSignalingChannelRequest>
  Model::DescribeSignalingChannelOutcomeCallable DescribeSignalingChannelCallable(
      const DescribeSignalingChannelRequestT& request = {}) const {
    return SubmitCallable(&KinesisVideoClient::DescribeSignalingChannel, request);
  }
 
  template <typename DescribeSignalingChannelRequestT = Model::DescribeSignalingChannelRequest>
  void DescribeSignalingChannelAsync(const DescribeSignalingChannelResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const DescribeSignalingChannelRequestT& request = {}) const {
    return SubmitAsync(&KinesisVideoClient::DescribeSignalingChannel, request, handler, context);
  }
 
  virtual Model::DescribeStreamOutcome DescribeStream(const Model::DescribeStreamRequest& request = {}) const;
 
  template <typename DescribeStreamRequestT = Model::DescribeStreamRequest>
  Model::DescribeStreamOutcomeCallable DescribeStreamCallable(const DescribeStreamRequestT& request = {}) const {
    return SubmitCallable(&KinesisVideoClient::DescribeStream, request);
  }
 
  template <typename DescribeStreamRequestT = Model::DescribeStreamRequest>
  void DescribeStreamAsync(const DescribeStreamResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const DescribeStreamRequestT& request = {}) const {
    return SubmitAsync(&KinesisVideoClient::DescribeStream, request, handler, context);
  }
 
  virtual Model::DescribeStreamStorageConfigurationOutcome DescribeStreamStorageConfiguration(
      const Model::DescribeStreamStorageConfigurationRequest& request = {}) const;
 
  template <typename DescribeStreamStorageConfigurationRequestT = Model::DescribeStreamStorageConfigurationRequest>
  Model::DescribeStreamStorageConfigurationOutcomeCallable DescribeStreamStorageConfigurationCallable(
      const DescribeStreamStorageConfigurationRequestT& request = {}) const {
    return SubmitCallable(&KinesisVideoClient::DescribeStreamStorageConfiguration, request);
  }
 
  template <typename DescribeStreamStorageConfigurationRequestT = Model::DescribeStreamStorageConfigurationRequest>
  void DescribeStreamStorageConfigurationAsync(const DescribeStreamStorageConfigurationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                               const DescribeStreamStorageConfigurationRequestT& request = {}) const {
    return SubmitAsync(&KinesisVideoClient::DescribeStreamStorageConfiguration, request, handler, context);
  }
 
  virtual Model::GetDataEndpointOutcome GetDataEndpoint(const Model::GetDataEndpointRequest& request) const;
 
  template <typename GetDataEndpointRequestT = Model::GetDataEndpointRequest>
  Model::GetDataEndpointOutcomeCallable GetDataEndpointCallable(const GetDataEndpointRequestT& request) const {
    return SubmitCallable(&KinesisVideoClient::GetDataEndpoint, request);
  }
 
  template <typename GetDataEndpointRequestT = Model::GetDataEndpointRequest>
  void GetDataEndpointAsync(const GetDataEndpointRequestT& request, const GetDataEndpointResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisVideoClient::GetDataEndpoint, request, handler, context);
  }
 
  virtual Model::GetSignalingChannelEndpointOutcome GetSignalingChannelEndpoint(
      const Model::GetSignalingChannelEndpointRequest& request) const;
 
  template <typename GetSignalingChannelEndpointRequestT = Model::GetSignalingChannelEndpointRequest>
  Model::GetSignalingChannelEndpointOutcomeCallable GetSignalingChannelEndpointCallable(
      const GetSignalingChannelEndpointRequestT& request) const {
    return SubmitCallable(&KinesisVideoClient::GetSignalingChannelEndpoint, request);
  }
 
  template <typename GetSignalingChannelEndpointRequestT = Model::GetSignalingChannelEndpointRequest>
  void GetSignalingChannelEndpointAsync(const GetSignalingChannelEndpointRequestT& request,
                                        const GetSignalingChannelEndpointResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisVideoClient::GetSignalingChannelEndpoint, request, handler, context);
  }
 
  virtual Model::ListEdgeAgentConfigurationsOutcome ListEdgeAgentConfigurations(
      const Model::ListEdgeAgentConfigurationsRequest& request) const;
 
  template <typename ListEdgeAgentConfigurationsRequestT = Model::ListEdgeAgentConfigurationsRequest>
  Model::ListEdgeAgentConfigurationsOutcomeCallable ListEdgeAgentConfigurationsCallable(
      const ListEdgeAgentConfigurationsRequestT& request) const {
    return SubmitCallable(&KinesisVideoClient::ListEdgeAgentConfigurations, request);
  }
 
  template <typename ListEdgeAgentConfigurationsRequestT = Model::ListEdgeAgentConfigurationsRequest>
  void ListEdgeAgentConfigurationsAsync(const ListEdgeAgentConfigurationsRequestT& request,
                                        const ListEdgeAgentConfigurationsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisVideoClient::ListEdgeAgentConfigurations, request, handler, context);
  }
 
  virtual Model::ListSignalingChannelsOutcome ListSignalingChannels(const Model::ListSignalingChannelsRequest& request = {}) const;
 
  template <typename ListSignalingChannelsRequestT = Model::ListSignalingChannelsRequest>
  Model::ListSignalingChannelsOutcomeCallable ListSignalingChannelsCallable(const ListSignalingChannelsRequestT& request = {}) const {
    return SubmitCallable(&KinesisVideoClient::ListSignalingChannels, request);
  }
 
  template <typename ListSignalingChannelsRequestT = Model::ListSignalingChannelsRequest>
  void ListSignalingChannelsAsync(const ListSignalingChannelsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const ListSignalingChannelsRequestT& request = {}) const {
    return SubmitAsync(&KinesisVideoClient::ListSignalingChannels, 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(&KinesisVideoClient::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(&KinesisVideoClient::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(&KinesisVideoClient::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(&KinesisVideoClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListTagsForStreamOutcome ListTagsForStream(const Model::ListTagsForStreamRequest& request = {}) const;
 
  template <typename ListTagsForStreamRequestT = Model::ListTagsForStreamRequest>
  Model::ListTagsForStreamOutcomeCallable ListTagsForStreamCallable(const ListTagsForStreamRequestT& request = {}) const {
    return SubmitCallable(&KinesisVideoClient::ListTagsForStream, request);
  }
 
  template <typename ListTagsForStreamRequestT = Model::ListTagsForStreamRequest>
  void ListTagsForStreamAsync(const ListTagsForStreamResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListTagsForStreamRequestT& request = {}) const {
    return SubmitAsync(&KinesisVideoClient::ListTagsForStream, request, handler, context);
  }
 
  virtual Model::StartEdgeConfigurationUpdateOutcome StartEdgeConfigurationUpdate(
      const Model::StartEdgeConfigurationUpdateRequest& request) const;
 
  template <typename StartEdgeConfigurationUpdateRequestT = Model::StartEdgeConfigurationUpdateRequest>
  Model::StartEdgeConfigurationUpdateOutcomeCallable StartEdgeConfigurationUpdateCallable(
      const StartEdgeConfigurationUpdateRequestT& request) const {
    return SubmitCallable(&KinesisVideoClient::StartEdgeConfigurationUpdate, request);
  }
 
  template <typename StartEdgeConfigurationUpdateRequestT = Model::StartEdgeConfigurationUpdateRequest>
  void StartEdgeConfigurationUpdateAsync(const StartEdgeConfigurationUpdateRequestT& request,
                                         const StartEdgeConfigurationUpdateResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisVideoClient::StartEdgeConfigurationUpdate, 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(&KinesisVideoClient::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(&KinesisVideoClient::TagResource, request, handler, context);
  }
 
  virtual Model::TagStreamOutcome TagStream(const Model::TagStreamRequest& request) const;
 
  template <typename TagStreamRequestT = Model::TagStreamRequest>
  Model::TagStreamOutcomeCallable TagStreamCallable(const TagStreamRequestT& request) const {
    return SubmitCallable(&KinesisVideoClient::TagStream, request);
  }
 
  template <typename TagStreamRequestT = Model::TagStreamRequest>
  void TagStreamAsync(const TagStreamRequestT& request, const TagStreamResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisVideoClient::TagStream, 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(&KinesisVideoClient::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(&KinesisVideoClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UntagStreamOutcome UntagStream(const Model::UntagStreamRequest& request) const;
 
  template <typename UntagStreamRequestT = Model::UntagStreamRequest>
  Model::UntagStreamOutcomeCallable UntagStreamCallable(const UntagStreamRequestT& request) const {
    return SubmitCallable(&KinesisVideoClient::UntagStream, request);
  }
 
  template <typename UntagStreamRequestT = Model::UntagStreamRequest>
  void UntagStreamAsync(const UntagStreamRequestT& request, const UntagStreamResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisVideoClient::UntagStream, request, handler, context);
  }
 
  virtual Model::UpdateDataRetentionOutcome UpdateDataRetention(const Model::UpdateDataRetentionRequest& request) const;
 
  template <typename UpdateDataRetentionRequestT = Model::UpdateDataRetentionRequest>
  Model::UpdateDataRetentionOutcomeCallable UpdateDataRetentionCallable(const UpdateDataRetentionRequestT& request) const {
    return SubmitCallable(&KinesisVideoClient::UpdateDataRetention, request);
  }
 
  template <typename UpdateDataRetentionRequestT = Model::UpdateDataRetentionRequest>
  void UpdateDataRetentionAsync(const UpdateDataRetentionRequestT& request, const UpdateDataRetentionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisVideoClient::UpdateDataRetention, request, handler, context);
  }
 
  virtual Model::UpdateImageGenerationConfigurationOutcome UpdateImageGenerationConfiguration(
      const Model::UpdateImageGenerationConfigurationRequest& request = {}) const;
 
  template <typename UpdateImageGenerationConfigurationRequestT = Model::UpdateImageGenerationConfigurationRequest>
  Model::UpdateImageGenerationConfigurationOutcomeCallable UpdateImageGenerationConfigurationCallable(
      const UpdateImageGenerationConfigurationRequestT& request = {}) const {
    return SubmitCallable(&KinesisVideoClient::UpdateImageGenerationConfiguration, request);
  }
 
  template <typename UpdateImageGenerationConfigurationRequestT = Model::UpdateImageGenerationConfigurationRequest>
  void UpdateImageGenerationConfigurationAsync(const UpdateImageGenerationConfigurationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                               const UpdateImageGenerationConfigurationRequestT& request = {}) const {
    return SubmitAsync(&KinesisVideoClient::UpdateImageGenerationConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateMediaStorageConfigurationOutcome UpdateMediaStorageConfiguration(
      const Model::UpdateMediaStorageConfigurationRequest& request) const;
 
  template <typename UpdateMediaStorageConfigurationRequestT = Model::UpdateMediaStorageConfigurationRequest>
  Model::UpdateMediaStorageConfigurationOutcomeCallable UpdateMediaStorageConfigurationCallable(
      const UpdateMediaStorageConfigurationRequestT& request) const {
    return SubmitCallable(&KinesisVideoClient::UpdateMediaStorageConfiguration, request);
  }
 
  template <typename UpdateMediaStorageConfigurationRequestT = Model::UpdateMediaStorageConfigurationRequest>
  void UpdateMediaStorageConfigurationAsync(const UpdateMediaStorageConfigurationRequestT& request,
                                            const UpdateMediaStorageConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisVideoClient::UpdateMediaStorageConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateNotificationConfigurationOutcome UpdateNotificationConfiguration(
      const Model::UpdateNotificationConfigurationRequest& request = {}) const;
 
  template <typename UpdateNotificationConfigurationRequestT = Model::UpdateNotificationConfigurationRequest>
  Model::UpdateNotificationConfigurationOutcomeCallable UpdateNotificationConfigurationCallable(
      const UpdateNotificationConfigurationRequestT& request = {}) const {
    return SubmitCallable(&KinesisVideoClient::UpdateNotificationConfiguration, request);
  }
 
  template <typename UpdateNotificationConfigurationRequestT = Model::UpdateNotificationConfigurationRequest>
  void UpdateNotificationConfigurationAsync(const UpdateNotificationConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                            const UpdateNotificationConfigurationRequestT& request = {}) const {
    return SubmitAsync(&KinesisVideoClient::UpdateNotificationConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateSignalingChannelOutcome UpdateSignalingChannel(const Model::UpdateSignalingChannelRequest& request) const;
 
  template <typename UpdateSignalingChannelRequestT = Model::UpdateSignalingChannelRequest>
  Model::UpdateSignalingChannelOutcomeCallable UpdateSignalingChannelCallable(const UpdateSignalingChannelRequestT& request) const {
    return SubmitCallable(&KinesisVideoClient::UpdateSignalingChannel, request);
  }
 
  template <typename UpdateSignalingChannelRequestT = Model::UpdateSignalingChannelRequest>
  void UpdateSignalingChannelAsync(const UpdateSignalingChannelRequestT& request,
                                   const UpdateSignalingChannelResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisVideoClient::UpdateSignalingChannel, request, handler, context);
  }
 
  virtual Model::UpdateStreamOutcome UpdateStream(const Model::UpdateStreamRequest& request) const;
 
  template <typename UpdateStreamRequestT = Model::UpdateStreamRequest>
  Model::UpdateStreamOutcomeCallable UpdateStreamCallable(const UpdateStreamRequestT& request) const {
    return SubmitCallable(&KinesisVideoClient::UpdateStream, request);
  }
 
  template <typename UpdateStreamRequestT = Model::UpdateStreamRequest>
  void UpdateStreamAsync(const UpdateStreamRequestT& request, const UpdateStreamResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisVideoClient::UpdateStream, request, handler, context);
  }
 
  virtual Model::UpdateStreamStorageConfigurationOutcome UpdateStreamStorageConfiguration(
      const Model::UpdateStreamStorageConfigurationRequest& request) const;
 
  template <typename UpdateStreamStorageConfigurationRequestT = Model::UpdateStreamStorageConfigurationRequest>
  Model::UpdateStreamStorageConfigurationOutcomeCallable UpdateStreamStorageConfigurationCallable(
      const UpdateStreamStorageConfigurationRequestT& request) const {
    return SubmitCallable(&KinesisVideoClient::UpdateStreamStorageConfiguration, request);
  }
 
  template <typename UpdateStreamStorageConfigurationRequestT = Model::UpdateStreamStorageConfigurationRequest>
  void UpdateStreamStorageConfigurationAsync(const UpdateStreamStorageConfigurationRequestT& request,
                                             const UpdateStreamStorageConfigurationResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisVideoClient::UpdateStreamStorageConfiguration, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<KinesisVideoEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<KinesisVideoClient>;
  void init(const KinesisVideoClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, KinesisVideoError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  KinesisVideoClientConfiguration m_clientConfiguration;
  std::shared_ptr<KinesisVideoEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace KinesisVideo
}  // namespace Aws