KinesisServiceClientModel.h

 
#pragma once
 
/* Generic header includes */
#include <aws/core/client/AWSError.h>
#include <aws/core/client/AsyncCallerContext.h>
#include <aws/core/client/GenericClientConfiguration.h>
#include <aws/core/http/HttpTypes.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/kinesis/KinesisEndpointProvider.h>
#include <aws/kinesis/KinesisErrors.h>
 
#include <functional>
#include <future>
/* End of generic header includes */
 
/* Service model headers required in KinesisClient header */
#include <aws/core/NoResult.h>
#include <aws/kinesis/model/CreateChannelResult.h>
#include <aws/kinesis/model/DeleteStreamRequest.h>
#include <aws/kinesis/model/DeregisterStreamConsumerRequest.h>
#include <aws/kinesis/model/DescribeAccountSettingsRequest.h>
#include <aws/kinesis/model/DescribeAccountSettingsResult.h>
#include <aws/kinesis/model/DescribeChannelResult.h>
#include <aws/kinesis/model/DescribeLimitsRequest.h>
#include <aws/kinesis/model/DescribeLimitsResult.h>
#include <aws/kinesis/model/DescribeStreamConsumerRequest.h>
#include <aws/kinesis/model/DescribeStreamConsumerResult.h>
#include <aws/kinesis/model/DescribeStreamRequest.h>
#include <aws/kinesis/model/DescribeStreamResult.h>
#include <aws/kinesis/model/DescribeStreamSummaryRequest.h>
#include <aws/kinesis/model/DescribeStreamSummaryResult.h>
#include <aws/kinesis/model/DisableEnhancedMonitoringResult.h>
#include <aws/kinesis/model/EnableEnhancedMonitoringResult.h>
#include <aws/kinesis/model/GetRecordsResult.h>
#include <aws/kinesis/model/GetResourcePolicyResult.h>
#include <aws/kinesis/model/GetShardIteratorResult.h>
#include <aws/kinesis/model/ListChannelsRequest.h>
#include <aws/kinesis/model/ListChannelsResult.h>
#include <aws/kinesis/model/ListShardsRequest.h>
#include <aws/kinesis/model/ListShardsResult.h>
#include <aws/kinesis/model/ListStreamConsumersResult.h>
#include <aws/kinesis/model/ListStreamsRequest.h>
#include <aws/kinesis/model/ListStreamsResult.h>
#include <aws/kinesis/model/ListTagsForResourceResult.h>
#include <aws/kinesis/model/ListTagsForStreamRequest.h>
#include <aws/kinesis/model/ListTagsForStreamResult.h>
#include <aws/kinesis/model/PutRecordResult.h>
#include <aws/kinesis/model/PutRecordsResult.h>
#include <aws/kinesis/model/RegisterStreamConsumerResult.h>
#include <aws/kinesis/model/UpdateAccountSettingsResult.h>
#include <aws/kinesis/model/UpdateChannelResult.h>
#include <aws/kinesis/model/UpdateShardCountResult.h>
#include <aws/kinesis/model/UpdateStreamWarmThroughputResult.h>
/* End of service model headers required in KinesisClient header */
 
namespace Aws {
namespace Http {
class HttpClient;
class HttpClientFactory;
}  // namespace Http
 
namespace Utils {
template <typename R, typename E>
class Outcome;
 
namespace Threading {
class Executor;
}  // namespace Threading
}  // namespace Utils
 
namespace Auth {
class AWSCredentials;
class AWSCredentialsProvider;
}  // namespace Auth
 
namespace Client {
class RetryStrategy;
}  // namespace Client
 
namespace Kinesis {
using KinesisEndpointProviderBase = Aws::Kinesis::Endpoint::KinesisEndpointProviderBase;
using KinesisEndpointProvider = Aws::Kinesis::Endpoint::KinesisEndpointProvider;
 
namespace Model {
/* Service model forward declarations required in KinesisClient header */
class AddTagsToStreamRequest;
class CreateChannelRequest;
class CreateStreamRequest;
class DecreaseStreamRetentionPeriodRequest;
class DeleteChannelRequest;
class DeleteResourcePolicyRequest;
class DeleteStreamRequest;
class DeregisterStreamConsumerRequest;
class DescribeAccountSettingsRequest;
class DescribeChannelRequest;
class DescribeLimitsRequest;
class DescribeStreamRequest;
class DescribeStreamConsumerRequest;
class DescribeStreamSummaryRequest;
class DisableEnhancedMonitoringRequest;
class EnableEnhancedMonitoringRequest;
class GetRecordsRequest;
class GetResourcePolicyRequest;
class GetShardIteratorRequest;
class IncreaseStreamRetentionPeriodRequest;
class ListChannelsRequest;
class ListShardsRequest;
class ListStreamConsumersRequest;
class ListStreamsRequest;
class ListTagsForResourceRequest;
class ListTagsForStreamRequest;
class MergeShardsRequest;
class PutRecordRequest;
class PutRecordsRequest;
class PutResourcePolicyRequest;
class RegisterStreamConsumerRequest;
class RemoveTagsFromStreamRequest;
class SplitShardRequest;
class StartStreamEncryptionRequest;
class StopStreamEncryptionRequest;
class SubscribeToShardRequest;
class TagResourceRequest;
class UntagResourceRequest;
class UpdateAccountSettingsRequest;
class UpdateChannelRequest;
class UpdateMaxRecordSizeRequest;
class UpdateShardCountRequest;
class UpdateStreamModeRequest;
class UpdateStreamWarmThroughputRequest;
/* End of service model forward declarations required in KinesisClient header */
 
/* Service model Outcome class definitions */
typedef Aws::Utils::Outcome<Aws::NoResult, KinesisError> AddTagsToStreamOutcome;
typedef Aws::Utils::Outcome<CreateChannelResult, KinesisError> CreateChannelOutcome;
typedef Aws::Utils::Outcome<Aws::NoResult, KinesisError> CreateStreamOutcome;
typedef Aws::Utils::Outcome<Aws::NoResult, KinesisError> DecreaseStreamRetentionPeriodOutcome;
typedef Aws::Utils::Outcome<Aws::NoResult, KinesisError> DeleteChannelOutcome;
typedef Aws::Utils::Outcome<Aws::NoResult, KinesisError> DeleteResourcePolicyOutcome;
typedef Aws::Utils::Outcome<Aws::NoResult, KinesisError> DeleteStreamOutcome;
typedef Aws::Utils::Outcome<Aws::NoResult, KinesisError> DeregisterStreamConsumerOutcome;
typedef Aws::Utils::Outcome<DescribeAccountSettingsResult, KinesisError> DescribeAccountSettingsOutcome;
typedef Aws::Utils::Outcome<DescribeChannelResult, KinesisError> DescribeChannelOutcome;
typedef Aws::Utils::Outcome<DescribeLimitsResult, KinesisError> DescribeLimitsOutcome;
typedef Aws::Utils::Outcome<DescribeStreamResult, KinesisError> DescribeStreamOutcome;
typedef Aws::Utils::Outcome<DescribeStreamConsumerResult, KinesisError> DescribeStreamConsumerOutcome;
typedef Aws::Utils::Outcome<DescribeStreamSummaryResult, KinesisError> DescribeStreamSummaryOutcome;
typedef Aws::Utils::Outcome<DisableEnhancedMonitoringResult, KinesisError> DisableEnhancedMonitoringOutcome;
typedef Aws::Utils::Outcome<EnableEnhancedMonitoringResult, KinesisError> EnableEnhancedMonitoringOutcome;
typedef Aws::Utils::Outcome<GetRecordsResult, KinesisError> GetRecordsOutcome;
typedef Aws::Utils::Outcome<GetResourcePolicyResult, KinesisError> GetResourcePolicyOutcome;
typedef Aws::Utils::Outcome<GetShardIteratorResult, KinesisError> GetShardIteratorOutcome;
typedef Aws::Utils::Outcome<Aws::NoResult, KinesisError> IncreaseStreamRetentionPeriodOutcome;
typedef Aws::Utils::Outcome<ListChannelsResult, KinesisError> ListChannelsOutcome;
typedef Aws::Utils::Outcome<ListShardsResult, KinesisError> ListShardsOutcome;
typedef Aws::Utils::Outcome<ListStreamConsumersResult, KinesisError> ListStreamConsumersOutcome;
typedef Aws::Utils::Outcome<ListStreamsResult, KinesisError> ListStreamsOutcome;
typedef Aws::Utils::Outcome<ListTagsForResourceResult, KinesisError> ListTagsForResourceOutcome;
typedef Aws::Utils::Outcome<ListTagsForStreamResult, KinesisError> ListTagsForStreamOutcome;
typedef Aws::Utils::Outcome<Aws::NoResult, KinesisError> MergeShardsOutcome;
typedef Aws::Utils::Outcome<PutRecordResult, KinesisError> PutRecordOutcome;
typedef Aws::Utils::Outcome<PutRecordsResult, KinesisError> PutRecordsOutcome;
typedef Aws::Utils::Outcome<Aws::NoResult, KinesisError> PutResourcePolicyOutcome;
typedef Aws::Utils::Outcome<RegisterStreamConsumerResult, KinesisError> RegisterStreamConsumerOutcome;
typedef Aws::Utils::Outcome<Aws::NoResult, KinesisError> RemoveTagsFromStreamOutcome;
typedef Aws::Utils::Outcome<Aws::NoResult, KinesisError> SplitShardOutcome;
typedef Aws::Utils::Outcome<Aws::NoResult, KinesisError> StartStreamEncryptionOutcome;
typedef Aws::Utils::Outcome<Aws::NoResult, KinesisError> StopStreamEncryptionOutcome;
typedef Aws::Utils::Outcome<Aws::NoResult, KinesisError> SubscribeToShardOutcome;
typedef Aws::Utils::Outcome<Aws::NoResult, KinesisError> TagResourceOutcome;
typedef Aws::Utils::Outcome<Aws::NoResult, KinesisError> UntagResourceOutcome;
typedef Aws::Utils::Outcome<UpdateAccountSettingsResult, KinesisError> UpdateAccountSettingsOutcome;
typedef Aws::Utils::Outcome<UpdateChannelResult, KinesisError> UpdateChannelOutcome;
typedef Aws::Utils::Outcome<Aws::NoResult, KinesisError> UpdateMaxRecordSizeOutcome;
typedef Aws::Utils::Outcome<UpdateShardCountResult, KinesisError> UpdateShardCountOutcome;
typedef Aws::Utils::Outcome<Aws::NoResult, KinesisError> UpdateStreamModeOutcome;
typedef Aws::Utils::Outcome<UpdateStreamWarmThroughputResult, KinesisError> UpdateStreamWarmThroughputOutcome;
/* End of service model Outcome class definitions */
 
/* Service model Outcome callable definitions */
typedef std::future<AddTagsToStreamOutcome> AddTagsToStreamOutcomeCallable;
typedef std::future<CreateChannelOutcome> CreateChannelOutcomeCallable;
typedef std::future<CreateStreamOutcome> CreateStreamOutcomeCallable;
typedef std::future<DecreaseStreamRetentionPeriodOutcome> DecreaseStreamRetentionPeriodOutcomeCallable;
typedef std::future<DeleteChannelOutcome> DeleteChannelOutcomeCallable;
typedef std::future<DeleteResourcePolicyOutcome> DeleteResourcePolicyOutcomeCallable;
typedef std::future<DeleteStreamOutcome> DeleteStreamOutcomeCallable;
typedef std::future<DeregisterStreamConsumerOutcome> DeregisterStreamConsumerOutcomeCallable;
typedef std::future<DescribeAccountSettingsOutcome> DescribeAccountSettingsOutcomeCallable;
typedef std::future<DescribeChannelOutcome> DescribeChannelOutcomeCallable;
typedef std::future<DescribeLimitsOutcome> DescribeLimitsOutcomeCallable;
typedef std::future<DescribeStreamOutcome> DescribeStreamOutcomeCallable;
typedef std::future<DescribeStreamConsumerOutcome> DescribeStreamConsumerOutcomeCallable;
typedef std::future<DescribeStreamSummaryOutcome> DescribeStreamSummaryOutcomeCallable;
typedef std::future<DisableEnhancedMonitoringOutcome> DisableEnhancedMonitoringOutcomeCallable;
typedef std::future<EnableEnhancedMonitoringOutcome> EnableEnhancedMonitoringOutcomeCallable;
typedef std::future<GetRecordsOutcome> GetRecordsOutcomeCallable;
typedef std::future<GetResourcePolicyOutcome> GetResourcePolicyOutcomeCallable;
typedef std::future<GetShardIteratorOutcome> GetShardIteratorOutcomeCallable;
typedef std::future<IncreaseStreamRetentionPeriodOutcome> IncreaseStreamRetentionPeriodOutcomeCallable;
typedef std::future<ListChannelsOutcome> ListChannelsOutcomeCallable;
typedef std::future<ListShardsOutcome> ListShardsOutcomeCallable;
typedef std::future<ListStreamConsumersOutcome> ListStreamConsumersOutcomeCallable;
typedef std::future<ListStreamsOutcome> ListStreamsOutcomeCallable;
typedef std::future<ListTagsForResourceOutcome> ListTagsForResourceOutcomeCallable;
typedef std::future<ListTagsForStreamOutcome> ListTagsForStreamOutcomeCallable;
typedef std::future<MergeShardsOutcome> MergeShardsOutcomeCallable;
typedef std::future<PutRecordOutcome> PutRecordOutcomeCallable;
typedef std::future<PutRecordsOutcome> PutRecordsOutcomeCallable;
typedef std::future<PutResourcePolicyOutcome> PutResourcePolicyOutcomeCallable;
typedef std::future<RegisterStreamConsumerOutcome> RegisterStreamConsumerOutcomeCallable;
typedef std::future<RemoveTagsFromStreamOutcome> RemoveTagsFromStreamOutcomeCallable;
typedef std::future<SplitShardOutcome> SplitShardOutcomeCallable;
typedef std::future<StartStreamEncryptionOutcome> StartStreamEncryptionOutcomeCallable;
typedef std::future<StopStreamEncryptionOutcome> StopStreamEncryptionOutcomeCallable;
typedef std::future<SubscribeToShardOutcome> SubscribeToShardOutcomeCallable;
typedef std::future<TagResourceOutcome> TagResourceOutcomeCallable;
typedef std::future<UntagResourceOutcome> UntagResourceOutcomeCallable;
typedef std::future<UpdateAccountSettingsOutcome> UpdateAccountSettingsOutcomeCallable;
typedef std::future<UpdateChannelOutcome> UpdateChannelOutcomeCallable;
typedef std::future<UpdateMaxRecordSizeOutcome> UpdateMaxRecordSizeOutcomeCallable;
typedef std::future<UpdateShardCountOutcome> UpdateShardCountOutcomeCallable;
typedef std::future<UpdateStreamModeOutcome> UpdateStreamModeOutcomeCallable;
typedef std::future<UpdateStreamWarmThroughputOutcome> UpdateStreamWarmThroughputOutcomeCallable;
/* End of service model Outcome callable definitions */
}  // namespace Model
 
class KinesisClient;
 
/* Service model async handlers definitions */
typedef std::function<void(const KinesisClient*, const Model::AddTagsToStreamRequest&, const Model::AddTagsToStreamOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    AddTagsToStreamResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::CreateChannelRequest&, const Model::CreateChannelOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    CreateChannelResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::CreateStreamRequest&, const Model::CreateStreamOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    CreateStreamResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::DecreaseStreamRetentionPeriodRequest&,
                           const Model::DecreaseStreamRetentionPeriodOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    DecreaseStreamRetentionPeriodResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::DeleteChannelRequest&, const Model::DeleteChannelOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    DeleteChannelResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::DeleteResourcePolicyRequest&, const Model::DeleteResourcePolicyOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    DeleteResourcePolicyResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::DeleteStreamRequest&, const Model::DeleteStreamOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    DeleteStreamResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::DeregisterStreamConsumerRequest&,
                           const Model::DeregisterStreamConsumerOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    DeregisterStreamConsumerResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::DescribeAccountSettingsRequest&, const Model::DescribeAccountSettingsOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    DescribeAccountSettingsResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::DescribeChannelRequest&, const Model::DescribeChannelOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    DescribeChannelResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::DescribeLimitsRequest&, const Model::DescribeLimitsOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    DescribeLimitsResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::DescribeStreamRequest&, const Model::DescribeStreamOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    DescribeStreamResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::DescribeStreamConsumerRequest&, const Model::DescribeStreamConsumerOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    DescribeStreamConsumerResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::DescribeStreamSummaryRequest&, const Model::DescribeStreamSummaryOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    DescribeStreamSummaryResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::DisableEnhancedMonitoringRequest&,
                           const Model::DisableEnhancedMonitoringOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    DisableEnhancedMonitoringResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::EnableEnhancedMonitoringRequest&,
                           const Model::EnableEnhancedMonitoringOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    EnableEnhancedMonitoringResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::GetRecordsRequest&, const Model::GetRecordsOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    GetRecordsResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::GetResourcePolicyRequest&, const Model::GetResourcePolicyOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    GetResourcePolicyResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::GetShardIteratorRequest&, const Model::GetShardIteratorOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    GetShardIteratorResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::IncreaseStreamRetentionPeriodRequest&,
                           const Model::IncreaseStreamRetentionPeriodOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    IncreaseStreamRetentionPeriodResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::ListChannelsRequest&, const Model::ListChannelsOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    ListChannelsResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::ListShardsRequest&, const Model::ListShardsOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    ListShardsResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::ListStreamConsumersRequest&, const Model::ListStreamConsumersOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    ListStreamConsumersResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::ListStreamsRequest&, const Model::ListStreamsOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    ListStreamsResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::ListTagsForResourceRequest&, const Model::ListTagsForResourceOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    ListTagsForResourceResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::ListTagsForStreamRequest&, const Model::ListTagsForStreamOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    ListTagsForStreamResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::MergeShardsRequest&, const Model::MergeShardsOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    MergeShardsResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::PutRecordRequest&, const Model::PutRecordOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    PutRecordResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::PutRecordsRequest&, const Model::PutRecordsOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    PutRecordsResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::PutResourcePolicyRequest&, const Model::PutResourcePolicyOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    PutResourcePolicyResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::RegisterStreamConsumerRequest&, const Model::RegisterStreamConsumerOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    RegisterStreamConsumerResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::RemoveTagsFromStreamRequest&, const Model::RemoveTagsFromStreamOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    RemoveTagsFromStreamResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::SplitShardRequest&, const Model::SplitShardOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    SplitShardResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::StartStreamEncryptionRequest&, const Model::StartStreamEncryptionOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    StartStreamEncryptionResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::StopStreamEncryptionRequest&, const Model::StopStreamEncryptionOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    StopStreamEncryptionResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::SubscribeToShardRequest&, const Model::SubscribeToShardOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    SubscribeToShardResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::TagResourceRequest&, const Model::TagResourceOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    TagResourceResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::UntagResourceRequest&, const Model::UntagResourceOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    UntagResourceResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::UpdateAccountSettingsRequest&, const Model::UpdateAccountSettingsOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    UpdateAccountSettingsResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::UpdateChannelRequest&, const Model::UpdateChannelOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    UpdateChannelResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::UpdateMaxRecordSizeRequest&, const Model::UpdateMaxRecordSizeOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    UpdateMaxRecordSizeResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::UpdateShardCountRequest&, const Model::UpdateShardCountOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    UpdateShardCountResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::UpdateStreamModeRequest&, const Model::UpdateStreamModeOutcome&,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    UpdateStreamModeResponseReceivedHandler;
typedef std::function<void(const KinesisClient*, const Model::UpdateStreamWarmThroughputRequest&,
                           const Model::UpdateStreamWarmThroughputOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
    UpdateStreamWarmThroughputResponseReceivedHandler;
/* End of service model async handlers definitions */
}  // namespace Kinesis
}  // namespace Aws