KinesisVideoClient.h

 
#pragma once
#include <aws/kinesisvideo/KinesisVideo_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/kinesisvideo/KinesisVideoServiceClientModel.h>
 
namespace Aws
{
namespace KinesisVideo
{
  class AWS_KINESISVIDEO_API KinesisVideoClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<KinesisVideoEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<KinesisVideoClient>;
      void init(const KinesisVideoClientConfiguration& clientConfiguration);
 
      KinesisVideoClientConfiguration m_clientConfiguration;
      std::shared_ptr<KinesisVideoEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace KinesisVideo
} // namespace Aws