KinesisClient.h

 
#pragma once
#include <aws/kinesis/Kinesis_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/kinesis/KinesisServiceClientModel.h>
 
namespace Aws
{
namespace Kinesis
{
  class AWS_KINESIS_API KinesisClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<KinesisClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef KinesisClientConfiguration ClientConfigurationType;
      typedef KinesisEndpointProvider EndpointProviderType;
 
        KinesisClient(const Aws::Kinesis::KinesisClientConfiguration& clientConfiguration = Aws::Kinesis::KinesisClientConfiguration(),
                      std::shared_ptr<KinesisEndpointProviderBase> endpointProvider = nullptr);
 
        KinesisClient(const Aws::Auth::AWSCredentials& credentials,
                      std::shared_ptr<KinesisEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::Kinesis::KinesisClientConfiguration& clientConfiguration = Aws::Kinesis::KinesisClientConfiguration());
 
        KinesisClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      std::shared_ptr<KinesisEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::Kinesis::KinesisClientConfiguration& clientConfiguration = Aws::Kinesis::KinesisClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        KinesisClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        KinesisClient(const Aws::Auth::AWSCredentials& credentials,
                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
        KinesisClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~KinesisClient();
 
        virtual Model::AddTagsToStreamOutcome AddTagsToStream(const Model::AddTagsToStreamRequest& request) const;
 
        template<typename AddTagsToStreamRequestT = Model::AddTagsToStreamRequest>
        Model::AddTagsToStreamOutcomeCallable AddTagsToStreamCallable(const AddTagsToStreamRequestT& request) const
        {
            return SubmitCallable(&KinesisClient::AddTagsToStream, request);
        }
 
        template<typename AddTagsToStreamRequestT = Model::AddTagsToStreamRequest>
        void AddTagsToStreamAsync(const AddTagsToStreamRequestT& request, const AddTagsToStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KinesisClient::AddTagsToStream, 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(&KinesisClient::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(&KinesisClient::CreateStream, request, handler, context);
        }
 
        virtual Model::DecreaseStreamRetentionPeriodOutcome DecreaseStreamRetentionPeriod(const Model::DecreaseStreamRetentionPeriodRequest& request) const;
 
        template<typename DecreaseStreamRetentionPeriodRequestT = Model::DecreaseStreamRetentionPeriodRequest>
        Model::DecreaseStreamRetentionPeriodOutcomeCallable DecreaseStreamRetentionPeriodCallable(const DecreaseStreamRetentionPeriodRequestT& request) const
        {
            return SubmitCallable(&KinesisClient::DecreaseStreamRetentionPeriod, request);
        }
 
        template<typename DecreaseStreamRetentionPeriodRequestT = Model::DecreaseStreamRetentionPeriodRequest>
        void DecreaseStreamRetentionPeriodAsync(const DecreaseStreamRetentionPeriodRequestT& request, const DecreaseStreamRetentionPeriodResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KinesisClient::DecreaseStreamRetentionPeriod, request, handler, context);
        }
 
        virtual Model::DeleteResourcePolicyOutcome DeleteResourcePolicy(const Model::DeleteResourcePolicyRequest& request) const;
 
        template<typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
        Model::DeleteResourcePolicyOutcomeCallable DeleteResourcePolicyCallable(const DeleteResourcePolicyRequestT& request) const
        {
            return SubmitCallable(&KinesisClient::DeleteResourcePolicy, request);
        }
 
        template<typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
        void DeleteResourcePolicyAsync(const DeleteResourcePolicyRequestT& request, const DeleteResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KinesisClient::DeleteResourcePolicy, 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(&KinesisClient::DeleteStream, request);
        }
 
        template<typename DeleteStreamRequestT = Model::DeleteStreamRequest>
        void DeleteStreamAsync(const DeleteStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteStreamRequestT& request = {}) const
        {
            return SubmitAsync(&KinesisClient::DeleteStream, request, handler, context);
        }
 
        virtual Model::DeregisterStreamConsumerOutcome DeregisterStreamConsumer(const Model::DeregisterStreamConsumerRequest& request = {}) const;
 
        template<typename DeregisterStreamConsumerRequestT = Model::DeregisterStreamConsumerRequest>
        Model::DeregisterStreamConsumerOutcomeCallable DeregisterStreamConsumerCallable(const DeregisterStreamConsumerRequestT& request = {}) const
        {
            return SubmitCallable(&KinesisClient::DeregisterStreamConsumer, request);
        }
 
        template<typename DeregisterStreamConsumerRequestT = Model::DeregisterStreamConsumerRequest>
        void DeregisterStreamConsumerAsync(const DeregisterStreamConsumerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeregisterStreamConsumerRequestT& request = {}) const
        {
            return SubmitAsync(&KinesisClient::DeregisterStreamConsumer, request, handler, context);
        }
 
        virtual Model::DescribeLimitsOutcome DescribeLimits(const Model::DescribeLimitsRequest& request = {}) const;
 
        template<typename DescribeLimitsRequestT = Model::DescribeLimitsRequest>
        Model::DescribeLimitsOutcomeCallable DescribeLimitsCallable(const DescribeLimitsRequestT& request = {}) const
        {
            return SubmitCallable(&KinesisClient::DescribeLimits, request);
        }
 
        template<typename DescribeLimitsRequestT = Model::DescribeLimitsRequest>
        void DescribeLimitsAsync(const DescribeLimitsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeLimitsRequestT& request = {}) const
        {
            return SubmitAsync(&KinesisClient::DescribeLimits, 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(&KinesisClient::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(&KinesisClient::DescribeStream, request, handler, context);
        }
 
        virtual Model::DescribeStreamConsumerOutcome DescribeStreamConsumer(const Model::DescribeStreamConsumerRequest& request = {}) const;
 
        template<typename DescribeStreamConsumerRequestT = Model::DescribeStreamConsumerRequest>
        Model::DescribeStreamConsumerOutcomeCallable DescribeStreamConsumerCallable(const DescribeStreamConsumerRequestT& request = {}) const
        {
            return SubmitCallable(&KinesisClient::DescribeStreamConsumer, request);
        }
 
        template<typename DescribeStreamConsumerRequestT = Model::DescribeStreamConsumerRequest>
        void DescribeStreamConsumerAsync(const DescribeStreamConsumerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeStreamConsumerRequestT& request = {}) const
        {
            return SubmitAsync(&KinesisClient::DescribeStreamConsumer, request, handler, context);
        }
 
        virtual Model::DescribeStreamSummaryOutcome DescribeStreamSummary(const Model::DescribeStreamSummaryRequest& request = {}) const;
 
        template<typename DescribeStreamSummaryRequestT = Model::DescribeStreamSummaryRequest>
        Model::DescribeStreamSummaryOutcomeCallable DescribeStreamSummaryCallable(const DescribeStreamSummaryRequestT& request = {}) const
        {
            return SubmitCallable(&KinesisClient::DescribeStreamSummary, request);
        }
 
        template<typename DescribeStreamSummaryRequestT = Model::DescribeStreamSummaryRequest>
        void DescribeStreamSummaryAsync(const DescribeStreamSummaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeStreamSummaryRequestT& request = {}) const
        {
            return SubmitAsync(&KinesisClient::DescribeStreamSummary, request, handler, context);
        }
 
        virtual Model::DisableEnhancedMonitoringOutcome DisableEnhancedMonitoring(const Model::DisableEnhancedMonitoringRequest& request) const;
 
        template<typename DisableEnhancedMonitoringRequestT = Model::DisableEnhancedMonitoringRequest>
        Model::DisableEnhancedMonitoringOutcomeCallable DisableEnhancedMonitoringCallable(const DisableEnhancedMonitoringRequestT& request) const
        {
            return SubmitCallable(&KinesisClient::DisableEnhancedMonitoring, request);
        }
 
        template<typename DisableEnhancedMonitoringRequestT = Model::DisableEnhancedMonitoringRequest>
        void DisableEnhancedMonitoringAsync(const DisableEnhancedMonitoringRequestT& request, const DisableEnhancedMonitoringResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KinesisClient::DisableEnhancedMonitoring, request, handler, context);
        }
 
        virtual Model::EnableEnhancedMonitoringOutcome EnableEnhancedMonitoring(const Model::EnableEnhancedMonitoringRequest& request) const;
 
        template<typename EnableEnhancedMonitoringRequestT = Model::EnableEnhancedMonitoringRequest>
        Model::EnableEnhancedMonitoringOutcomeCallable EnableEnhancedMonitoringCallable(const EnableEnhancedMonitoringRequestT& request) const
        {
            return SubmitCallable(&KinesisClient::EnableEnhancedMonitoring, request);
        }
 
        template<typename EnableEnhancedMonitoringRequestT = Model::EnableEnhancedMonitoringRequest>
        void EnableEnhancedMonitoringAsync(const EnableEnhancedMonitoringRequestT& request, const EnableEnhancedMonitoringResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KinesisClient::EnableEnhancedMonitoring, request, handler, context);
        }
 
        virtual Model::GetRecordsOutcome GetRecords(const Model::GetRecordsRequest& request) const;
 
        template<typename GetRecordsRequestT = Model::GetRecordsRequest>
        Model::GetRecordsOutcomeCallable GetRecordsCallable(const GetRecordsRequestT& request) const
        {
            return SubmitCallable(&KinesisClient::GetRecords, request);
        }
 
        template<typename GetRecordsRequestT = Model::GetRecordsRequest>
        void GetRecordsAsync(const GetRecordsRequestT& request, const GetRecordsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KinesisClient::GetRecords, request, handler, context);
        }
 
        virtual Model::GetResourcePolicyOutcome GetResourcePolicy(const Model::GetResourcePolicyRequest& request) const;
 
        template<typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
        Model::GetResourcePolicyOutcomeCallable GetResourcePolicyCallable(const GetResourcePolicyRequestT& request) const
        {
            return SubmitCallable(&KinesisClient::GetResourcePolicy, request);
        }
 
        template<typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
        void GetResourcePolicyAsync(const GetResourcePolicyRequestT& request, const GetResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KinesisClient::GetResourcePolicy, request, handler, context);
        }
 
        virtual Model::GetShardIteratorOutcome GetShardIterator(const Model::GetShardIteratorRequest& request) const;
 
        template<typename GetShardIteratorRequestT = Model::GetShardIteratorRequest>
        Model::GetShardIteratorOutcomeCallable GetShardIteratorCallable(const GetShardIteratorRequestT& request) const
        {
            return SubmitCallable(&KinesisClient::GetShardIterator, request);
        }
 
        template<typename GetShardIteratorRequestT = Model::GetShardIteratorRequest>
        void GetShardIteratorAsync(const GetShardIteratorRequestT& request, const GetShardIteratorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KinesisClient::GetShardIterator, request, handler, context);
        }
 
        virtual Model::IncreaseStreamRetentionPeriodOutcome IncreaseStreamRetentionPeriod(const Model::IncreaseStreamRetentionPeriodRequest& request) const;
 
        template<typename IncreaseStreamRetentionPeriodRequestT = Model::IncreaseStreamRetentionPeriodRequest>
        Model::IncreaseStreamRetentionPeriodOutcomeCallable IncreaseStreamRetentionPeriodCallable(const IncreaseStreamRetentionPeriodRequestT& request) const
        {
            return SubmitCallable(&KinesisClient::IncreaseStreamRetentionPeriod, request);
        }
 
        template<typename IncreaseStreamRetentionPeriodRequestT = Model::IncreaseStreamRetentionPeriodRequest>
        void IncreaseStreamRetentionPeriodAsync(const IncreaseStreamRetentionPeriodRequestT& request, const IncreaseStreamRetentionPeriodResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KinesisClient::IncreaseStreamRetentionPeriod, request, handler, context);
        }
 
        virtual Model::ListShardsOutcome ListShards(const Model::ListShardsRequest& request = {}) const;
 
        template<typename ListShardsRequestT = Model::ListShardsRequest>
        Model::ListShardsOutcomeCallable ListShardsCallable(const ListShardsRequestT& request = {}) const
        {
            return SubmitCallable(&KinesisClient::ListShards, request);
        }
 
        template<typename ListShardsRequestT = Model::ListShardsRequest>
        void ListShardsAsync(const ListShardsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListShardsRequestT& request = {}) const
        {
            return SubmitAsync(&KinesisClient::ListShards, request, handler, context);
        }
 
        virtual Model::ListStreamConsumersOutcome ListStreamConsumers(const Model::ListStreamConsumersRequest& request) const;
 
        template<typename ListStreamConsumersRequestT = Model::ListStreamConsumersRequest>
        Model::ListStreamConsumersOutcomeCallable ListStreamConsumersCallable(const ListStreamConsumersRequestT& request) const
        {
            return SubmitCallable(&KinesisClient::ListStreamConsumers, request);
        }
 
        template<typename ListStreamConsumersRequestT = Model::ListStreamConsumersRequest>
        void ListStreamConsumersAsync(const ListStreamConsumersRequestT& request, const ListStreamConsumersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KinesisClient::ListStreamConsumers, 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(&KinesisClient::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(&KinesisClient::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(&KinesisClient::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(&KinesisClient::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(&KinesisClient::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(&KinesisClient::ListTagsForStream, request, handler, context);
        }
 
        virtual Model::MergeShardsOutcome MergeShards(const Model::MergeShardsRequest& request) const;
 
        template<typename MergeShardsRequestT = Model::MergeShardsRequest>
        Model::MergeShardsOutcomeCallable MergeShardsCallable(const MergeShardsRequestT& request) const
        {
            return SubmitCallable(&KinesisClient::MergeShards, request);
        }
 
        template<typename MergeShardsRequestT = Model::MergeShardsRequest>
        void MergeShardsAsync(const MergeShardsRequestT& request, const MergeShardsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KinesisClient::MergeShards, request, handler, context);
        }
 
        virtual Model::PutRecordOutcome PutRecord(const Model::PutRecordRequest& request) const;
 
        template<typename PutRecordRequestT = Model::PutRecordRequest>
        Model::PutRecordOutcomeCallable PutRecordCallable(const PutRecordRequestT& request) const
        {
            return SubmitCallable(&KinesisClient::PutRecord, request);
        }
 
        template<typename PutRecordRequestT = Model::PutRecordRequest>
        void PutRecordAsync(const PutRecordRequestT& request, const PutRecordResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KinesisClient::PutRecord, request, handler, context);
        }
 
        virtual Model::PutRecordsOutcome PutRecords(const Model::PutRecordsRequest& request) const;
 
        template<typename PutRecordsRequestT = Model::PutRecordsRequest>
        Model::PutRecordsOutcomeCallable PutRecordsCallable(const PutRecordsRequestT& request) const
        {
            return SubmitCallable(&KinesisClient::PutRecords, request);
        }
 
        template<typename PutRecordsRequestT = Model::PutRecordsRequest>
        void PutRecordsAsync(const PutRecordsRequestT& request, const PutRecordsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KinesisClient::PutRecords, request, handler, context);
        }
 
        virtual Model::PutResourcePolicyOutcome PutResourcePolicy(const Model::PutResourcePolicyRequest& request) const;
 
        template<typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
        Model::PutResourcePolicyOutcomeCallable PutResourcePolicyCallable(const PutResourcePolicyRequestT& request) const
        {
            return SubmitCallable(&KinesisClient::PutResourcePolicy, request);
        }
 
        template<typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
        void PutResourcePolicyAsync(const PutResourcePolicyRequestT& request, const PutResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KinesisClient::PutResourcePolicy, request, handler, context);
        }
 
        virtual Model::RegisterStreamConsumerOutcome RegisterStreamConsumer(const Model::RegisterStreamConsumerRequest& request) const;
 
        template<typename RegisterStreamConsumerRequestT = Model::RegisterStreamConsumerRequest>
        Model::RegisterStreamConsumerOutcomeCallable RegisterStreamConsumerCallable(const RegisterStreamConsumerRequestT& request) const
        {
            return SubmitCallable(&KinesisClient::RegisterStreamConsumer, request);
        }
 
        template<typename RegisterStreamConsumerRequestT = Model::RegisterStreamConsumerRequest>
        void RegisterStreamConsumerAsync(const RegisterStreamConsumerRequestT& request, const RegisterStreamConsumerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KinesisClient::RegisterStreamConsumer, request, handler, context);
        }
 
        virtual Model::RemoveTagsFromStreamOutcome RemoveTagsFromStream(const Model::RemoveTagsFromStreamRequest& request) const;
 
        template<typename RemoveTagsFromStreamRequestT = Model::RemoveTagsFromStreamRequest>
        Model::RemoveTagsFromStreamOutcomeCallable RemoveTagsFromStreamCallable(const RemoveTagsFromStreamRequestT& request) const
        {
            return SubmitCallable(&KinesisClient::RemoveTagsFromStream, request);
        }
 
        template<typename RemoveTagsFromStreamRequestT = Model::RemoveTagsFromStreamRequest>
        void RemoveTagsFromStreamAsync(const RemoveTagsFromStreamRequestT& request, const RemoveTagsFromStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KinesisClient::RemoveTagsFromStream, request, handler, context);
        }
 
        virtual Model::SplitShardOutcome SplitShard(const Model::SplitShardRequest& request) const;
 
        template<typename SplitShardRequestT = Model::SplitShardRequest>
        Model::SplitShardOutcomeCallable SplitShardCallable(const SplitShardRequestT& request) const
        {
            return SubmitCallable(&KinesisClient::SplitShard, request);
        }
 
        template<typename SplitShardRequestT = Model::SplitShardRequest>
        void SplitShardAsync(const SplitShardRequestT& request, const SplitShardResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KinesisClient::SplitShard, request, handler, context);
        }
 
        virtual Model::StartStreamEncryptionOutcome StartStreamEncryption(const Model::StartStreamEncryptionRequest& request) const;
 
        template<typename StartStreamEncryptionRequestT = Model::StartStreamEncryptionRequest>
        Model::StartStreamEncryptionOutcomeCallable StartStreamEncryptionCallable(const StartStreamEncryptionRequestT& request) const
        {
            return SubmitCallable(&KinesisClient::StartStreamEncryption, request);
        }
 
        template<typename StartStreamEncryptionRequestT = Model::StartStreamEncryptionRequest>
        void StartStreamEncryptionAsync(const StartStreamEncryptionRequestT& request, const StartStreamEncryptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KinesisClient::StartStreamEncryption, request, handler, context);
        }
 
        virtual Model::StopStreamEncryptionOutcome StopStreamEncryption(const Model::StopStreamEncryptionRequest& request) const;
 
        template<typename StopStreamEncryptionRequestT = Model::StopStreamEncryptionRequest>
        Model::StopStreamEncryptionOutcomeCallable StopStreamEncryptionCallable(const StopStreamEncryptionRequestT& request) const
        {
            return SubmitCallable(&KinesisClient::StopStreamEncryption, request);
        }
 
        template<typename StopStreamEncryptionRequestT = Model::StopStreamEncryptionRequest>
        void StopStreamEncryptionAsync(const StopStreamEncryptionRequestT& request, const StopStreamEncryptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KinesisClient::StopStreamEncryption, request, handler, context);
        }
 
        virtual Model::SubscribeToShardOutcome SubscribeToShard(Model::SubscribeToShardRequest& request) const;
 
        template<typename SubscribeToShardRequestT = Model::SubscribeToShardRequest>
        Model::SubscribeToShardOutcomeCallable SubscribeToShardCallable(SubscribeToShardRequestT& request) const
        {
            return SubmitCallable(&KinesisClient::SubscribeToShard, request);
        }
 
        template<typename SubscribeToShardRequestT = Model::SubscribeToShardRequest>
        void SubscribeToShardAsync(SubscribeToShardRequestT& request, const SubscribeToShardResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KinesisClient::SubscribeToShard, 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(&KinesisClient::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(&KinesisClient::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(&KinesisClient::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(&KinesisClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateShardCountOutcome UpdateShardCount(const Model::UpdateShardCountRequest& request) const;
 
        template<typename UpdateShardCountRequestT = Model::UpdateShardCountRequest>
        Model::UpdateShardCountOutcomeCallable UpdateShardCountCallable(const UpdateShardCountRequestT& request) const
        {
            return SubmitCallable(&KinesisClient::UpdateShardCount, request);
        }
 
        template<typename UpdateShardCountRequestT = Model::UpdateShardCountRequest>
        void UpdateShardCountAsync(const UpdateShardCountRequestT& request, const UpdateShardCountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KinesisClient::UpdateShardCount, request, handler, context);
        }
 
        virtual Model::UpdateStreamModeOutcome UpdateStreamMode(const Model::UpdateStreamModeRequest& request) const;
 
        template<typename UpdateStreamModeRequestT = Model::UpdateStreamModeRequest>
        Model::UpdateStreamModeOutcomeCallable UpdateStreamModeCallable(const UpdateStreamModeRequestT& request) const
        {
            return SubmitCallable(&KinesisClient::UpdateStreamMode, request);
        }
 
        template<typename UpdateStreamModeRequestT = Model::UpdateStreamModeRequest>
        void UpdateStreamModeAsync(const UpdateStreamModeRequestT& request, const UpdateStreamModeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KinesisClient::UpdateStreamMode, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<KinesisEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<KinesisClient>;
      void init(const KinesisClientConfiguration& clientConfiguration);
 
      KinesisClientConfiguration m_clientConfiguration;
      std::shared_ptr<KinesisEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Kinesis
} // namespace Aws