KinesisClient.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/kinesis/KinesisPaginationBase.h>
#include <aws/kinesis/KinesisServiceClientModel.h>
#include <aws/kinesis/KinesisWaiter.h>
#include <aws/kinesis/Kinesis_EXPORTS.h>
 
namespace Aws {
namespace Kinesis {
class AWS_KINESIS_API KinesisClient : public Aws::Client::AWSJsonClient,
                                      public Aws::Client::ClientWithAsyncTemplateMethods<KinesisClient>,
                                      public KinesisPaginationBase<KinesisClient>,
                                      public KinesisWaiter<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::CreateChannelOutcome CreateChannel(const Model::CreateChannelRequest& request) const;
 
  template <typename CreateChannelRequestT = Model::CreateChannelRequest>
  Model::CreateChannelOutcomeCallable CreateChannelCallable(const CreateChannelRequestT& request) const {
    return SubmitCallable(&KinesisClient::CreateChannel, request);
  }
 
  template <typename CreateChannelRequestT = Model::CreateChannelRequest>
  void CreateChannelAsync(const CreateChannelRequestT& request, const CreateChannelResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisClient::CreateChannel, 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::DeleteChannelOutcome DeleteChannel(const Model::DeleteChannelRequest& request) const;
 
  template <typename DeleteChannelRequestT = Model::DeleteChannelRequest>
  Model::DeleteChannelOutcomeCallable DeleteChannelCallable(const DeleteChannelRequestT& request) const {
    return SubmitCallable(&KinesisClient::DeleteChannel, request);
  }
 
  template <typename DeleteChannelRequestT = Model::DeleteChannelRequest>
  void DeleteChannelAsync(const DeleteChannelRequestT& request, const DeleteChannelResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisClient::DeleteChannel, 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::DescribeAccountSettingsOutcome DescribeAccountSettings(const Model::DescribeAccountSettingsRequest& request = {}) const;
 
  template <typename DescribeAccountSettingsRequestT = Model::DescribeAccountSettingsRequest>
  Model::DescribeAccountSettingsOutcomeCallable DescribeAccountSettingsCallable(const DescribeAccountSettingsRequestT& request = {}) const {
    return SubmitCallable(&KinesisClient::DescribeAccountSettings, request);
  }
 
  template <typename DescribeAccountSettingsRequestT = Model::DescribeAccountSettingsRequest>
  void DescribeAccountSettingsAsync(const DescribeAccountSettingsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const DescribeAccountSettingsRequestT& request = {}) const {
    return SubmitAsync(&KinesisClient::DescribeAccountSettings, request, handler, context);
  }
 
  virtual Model::DescribeChannelOutcome DescribeChannel(const Model::DescribeChannelRequest& request) const;
 
  template <typename DescribeChannelRequestT = Model::DescribeChannelRequest>
  Model::DescribeChannelOutcomeCallable DescribeChannelCallable(const DescribeChannelRequestT& request) const {
    return SubmitCallable(&KinesisClient::DescribeChannel, request);
  }
 
  template <typename DescribeChannelRequestT = Model::DescribeChannelRequest>
  void DescribeChannelAsync(const DescribeChannelRequestT& request, const DescribeChannelResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisClient::DescribeChannel, 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::ListChannelsOutcome ListChannels(const Model::ListChannelsRequest& request = {}) const;
 
  template <typename ListChannelsRequestT = Model::ListChannelsRequest>
  Model::ListChannelsOutcomeCallable ListChannelsCallable(const ListChannelsRequestT& request = {}) const {
    return SubmitCallable(&KinesisClient::ListChannels, request);
  }
 
  template <typename ListChannelsRequestT = Model::ListChannelsRequest>
  void ListChannelsAsync(const ListChannelsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListChannelsRequestT& request = {}) const {
    return SubmitAsync(&KinesisClient::ListChannels, 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::UpdateAccountSettingsOutcome UpdateAccountSettings(const Model::UpdateAccountSettingsRequest& request) const;
 
  template <typename UpdateAccountSettingsRequestT = Model::UpdateAccountSettingsRequest>
  Model::UpdateAccountSettingsOutcomeCallable UpdateAccountSettingsCallable(const UpdateAccountSettingsRequestT& request) const {
    return SubmitCallable(&KinesisClient::UpdateAccountSettings, request);
  }
 
  template <typename UpdateAccountSettingsRequestT = Model::UpdateAccountSettingsRequest>
  void UpdateAccountSettingsAsync(const UpdateAccountSettingsRequestT& request, const UpdateAccountSettingsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisClient::UpdateAccountSettings, request, handler, context);
  }
 
  virtual Model::UpdateChannelOutcome UpdateChannel(const Model::UpdateChannelRequest& request) const;
 
  template <typename UpdateChannelRequestT = Model::UpdateChannelRequest>
  Model::UpdateChannelOutcomeCallable UpdateChannelCallable(const UpdateChannelRequestT& request) const {
    return SubmitCallable(&KinesisClient::UpdateChannel, request);
  }
 
  template <typename UpdateChannelRequestT = Model::UpdateChannelRequest>
  void UpdateChannelAsync(const UpdateChannelRequestT& request, const UpdateChannelResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisClient::UpdateChannel, request, handler, context);
  }
 
  virtual Model::UpdateMaxRecordSizeOutcome UpdateMaxRecordSize(const Model::UpdateMaxRecordSizeRequest& request) const;
 
  template <typename UpdateMaxRecordSizeRequestT = Model::UpdateMaxRecordSizeRequest>
  Model::UpdateMaxRecordSizeOutcomeCallable UpdateMaxRecordSizeCallable(const UpdateMaxRecordSizeRequestT& request) const {
    return SubmitCallable(&KinesisClient::UpdateMaxRecordSize, request);
  }
 
  template <typename UpdateMaxRecordSizeRequestT = Model::UpdateMaxRecordSizeRequest>
  void UpdateMaxRecordSizeAsync(const UpdateMaxRecordSizeRequestT& request, const UpdateMaxRecordSizeResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisClient::UpdateMaxRecordSize, 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);
  }
 
  virtual Model::UpdateStreamWarmThroughputOutcome UpdateStreamWarmThroughput(
      const Model::UpdateStreamWarmThroughputRequest& request) const;
 
  template <typename UpdateStreamWarmThroughputRequestT = Model::UpdateStreamWarmThroughputRequest>
  Model::UpdateStreamWarmThroughputOutcomeCallable UpdateStreamWarmThroughputCallable(
      const UpdateStreamWarmThroughputRequestT& request) const {
    return SubmitCallable(&KinesisClient::UpdateStreamWarmThroughput, request);
  }
 
  template <typename UpdateStreamWarmThroughputRequestT = Model::UpdateStreamWarmThroughputRequest>
  void UpdateStreamWarmThroughputAsync(const UpdateStreamWarmThroughputRequestT& request,
                                       const UpdateStreamWarmThroughputResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisClient::UpdateStreamWarmThroughput, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<KinesisEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<KinesisClient>;
  void init(const KinesisClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, KinesisError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  KinesisClientConfiguration m_clientConfiguration;
  std::shared_ptr<KinesisEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Kinesis
}  // namespace Aws