ElastiCacheClient.h

 
#pragma once
#include <aws/elasticache/ElastiCache_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/elasticache/ElastiCacheServiceClientModel.h>
 
namespace Aws
{
namespace ElastiCache
{
  class AWS_ELASTICACHE_API ElastiCacheClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods<ElastiCacheClient>
  {
    public:
      typedef Aws::Client::AWSXMLClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef ElastiCacheClientConfiguration ClientConfigurationType;
      typedef ElastiCacheEndpointProvider EndpointProviderType;
 
        ElastiCacheClient(const Aws::ElastiCache::ElastiCacheClientConfiguration& clientConfiguration = Aws::ElastiCache::ElastiCacheClientConfiguration(),
                          std::shared_ptr<ElastiCacheEndpointProviderBase> endpointProvider = nullptr);
 
        ElastiCacheClient(const Aws::Auth::AWSCredentials& credentials,
                          std::shared_ptr<ElastiCacheEndpointProviderBase> endpointProvider = nullptr,
                          const Aws::ElastiCache::ElastiCacheClientConfiguration& clientConfiguration = Aws::ElastiCache::ElastiCacheClientConfiguration());
 
        ElastiCacheClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                          std::shared_ptr<ElastiCacheEndpointProviderBase> endpointProvider = nullptr,
                          const Aws::ElastiCache::ElastiCacheClientConfiguration& clientConfiguration = Aws::ElastiCache::ElastiCacheClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        ElastiCacheClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ElastiCacheClient(const Aws::Auth::AWSCredentials& credentials,
                          const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ElastiCacheClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                          const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~ElastiCacheClient();
 
 
        Aws::String ConvertRequestToPresignedUrl(const Aws::AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const;
 
 
        virtual Model::AddTagsToResourceOutcome AddTagsToResource(const Model::AddTagsToResourceRequest& request) const;
 
        template<typename AddTagsToResourceRequestT = Model::AddTagsToResourceRequest>
        Model::AddTagsToResourceOutcomeCallable AddTagsToResourceCallable(const AddTagsToResourceRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::AddTagsToResource, request);
        }
 
        template<typename AddTagsToResourceRequestT = Model::AddTagsToResourceRequest>
        void AddTagsToResourceAsync(const AddTagsToResourceRequestT& request, const AddTagsToResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::AddTagsToResource, request, handler, context);
        }
 
        virtual Model::AuthorizeCacheSecurityGroupIngressOutcome AuthorizeCacheSecurityGroupIngress(const Model::AuthorizeCacheSecurityGroupIngressRequest& request) const;
 
        template<typename AuthorizeCacheSecurityGroupIngressRequestT = Model::AuthorizeCacheSecurityGroupIngressRequest>
        Model::AuthorizeCacheSecurityGroupIngressOutcomeCallable AuthorizeCacheSecurityGroupIngressCallable(const AuthorizeCacheSecurityGroupIngressRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::AuthorizeCacheSecurityGroupIngress, request);
        }
 
        template<typename AuthorizeCacheSecurityGroupIngressRequestT = Model::AuthorizeCacheSecurityGroupIngressRequest>
        void AuthorizeCacheSecurityGroupIngressAsync(const AuthorizeCacheSecurityGroupIngressRequestT& request, const AuthorizeCacheSecurityGroupIngressResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::AuthorizeCacheSecurityGroupIngress, request, handler, context);
        }
 
        virtual Model::BatchApplyUpdateActionOutcome BatchApplyUpdateAction(const Model::BatchApplyUpdateActionRequest& request) const;
 
        template<typename BatchApplyUpdateActionRequestT = Model::BatchApplyUpdateActionRequest>
        Model::BatchApplyUpdateActionOutcomeCallable BatchApplyUpdateActionCallable(const BatchApplyUpdateActionRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::BatchApplyUpdateAction, request);
        }
 
        template<typename BatchApplyUpdateActionRequestT = Model::BatchApplyUpdateActionRequest>
        void BatchApplyUpdateActionAsync(const BatchApplyUpdateActionRequestT& request, const BatchApplyUpdateActionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::BatchApplyUpdateAction, request, handler, context);
        }
 
        virtual Model::BatchStopUpdateActionOutcome BatchStopUpdateAction(const Model::BatchStopUpdateActionRequest& request) const;
 
        template<typename BatchStopUpdateActionRequestT = Model::BatchStopUpdateActionRequest>
        Model::BatchStopUpdateActionOutcomeCallable BatchStopUpdateActionCallable(const BatchStopUpdateActionRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::BatchStopUpdateAction, request);
        }
 
        template<typename BatchStopUpdateActionRequestT = Model::BatchStopUpdateActionRequest>
        void BatchStopUpdateActionAsync(const BatchStopUpdateActionRequestT& request, const BatchStopUpdateActionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::BatchStopUpdateAction, request, handler, context);
        }
 
        virtual Model::CompleteMigrationOutcome CompleteMigration(const Model::CompleteMigrationRequest& request) const;
 
        template<typename CompleteMigrationRequestT = Model::CompleteMigrationRequest>
        Model::CompleteMigrationOutcomeCallable CompleteMigrationCallable(const CompleteMigrationRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::CompleteMigration, request);
        }
 
        template<typename CompleteMigrationRequestT = Model::CompleteMigrationRequest>
        void CompleteMigrationAsync(const CompleteMigrationRequestT& request, const CompleteMigrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::CompleteMigration, request, handler, context);
        }
 
        virtual Model::CopyServerlessCacheSnapshotOutcome CopyServerlessCacheSnapshot(const Model::CopyServerlessCacheSnapshotRequest& request) const;
 
        template<typename CopyServerlessCacheSnapshotRequestT = Model::CopyServerlessCacheSnapshotRequest>
        Model::CopyServerlessCacheSnapshotOutcomeCallable CopyServerlessCacheSnapshotCallable(const CopyServerlessCacheSnapshotRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::CopyServerlessCacheSnapshot, request);
        }
 
        template<typename CopyServerlessCacheSnapshotRequestT = Model::CopyServerlessCacheSnapshotRequest>
        void CopyServerlessCacheSnapshotAsync(const CopyServerlessCacheSnapshotRequestT& request, const CopyServerlessCacheSnapshotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::CopyServerlessCacheSnapshot, request, handler, context);
        }
 
        virtual Model::CopySnapshotOutcome CopySnapshot(const Model::CopySnapshotRequest& request) const;
 
        template<typename CopySnapshotRequestT = Model::CopySnapshotRequest>
        Model::CopySnapshotOutcomeCallable CopySnapshotCallable(const CopySnapshotRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::CopySnapshot, request);
        }
 
        template<typename CopySnapshotRequestT = Model::CopySnapshotRequest>
        void CopySnapshotAsync(const CopySnapshotRequestT& request, const CopySnapshotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::CopySnapshot, request, handler, context);
        }
 
        virtual Model::CreateCacheClusterOutcome CreateCacheCluster(const Model::CreateCacheClusterRequest& request) const;
 
        template<typename CreateCacheClusterRequestT = Model::CreateCacheClusterRequest>
        Model::CreateCacheClusterOutcomeCallable CreateCacheClusterCallable(const CreateCacheClusterRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::CreateCacheCluster, request);
        }
 
        template<typename CreateCacheClusterRequestT = Model::CreateCacheClusterRequest>
        void CreateCacheClusterAsync(const CreateCacheClusterRequestT& request, const CreateCacheClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::CreateCacheCluster, request, handler, context);
        }
 
        virtual Model::CreateCacheParameterGroupOutcome CreateCacheParameterGroup(const Model::CreateCacheParameterGroupRequest& request) const;
 
        template<typename CreateCacheParameterGroupRequestT = Model::CreateCacheParameterGroupRequest>
        Model::CreateCacheParameterGroupOutcomeCallable CreateCacheParameterGroupCallable(const CreateCacheParameterGroupRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::CreateCacheParameterGroup, request);
        }
 
        template<typename CreateCacheParameterGroupRequestT = Model::CreateCacheParameterGroupRequest>
        void CreateCacheParameterGroupAsync(const CreateCacheParameterGroupRequestT& request, const CreateCacheParameterGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::CreateCacheParameterGroup, request, handler, context);
        }
 
        virtual Model::CreateCacheSecurityGroupOutcome CreateCacheSecurityGroup(const Model::CreateCacheSecurityGroupRequest& request) const;
 
        template<typename CreateCacheSecurityGroupRequestT = Model::CreateCacheSecurityGroupRequest>
        Model::CreateCacheSecurityGroupOutcomeCallable CreateCacheSecurityGroupCallable(const CreateCacheSecurityGroupRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::CreateCacheSecurityGroup, request);
        }
 
        template<typename CreateCacheSecurityGroupRequestT = Model::CreateCacheSecurityGroupRequest>
        void CreateCacheSecurityGroupAsync(const CreateCacheSecurityGroupRequestT& request, const CreateCacheSecurityGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::CreateCacheSecurityGroup, request, handler, context);
        }
 
        virtual Model::CreateCacheSubnetGroupOutcome CreateCacheSubnetGroup(const Model::CreateCacheSubnetGroupRequest& request) const;
 
        template<typename CreateCacheSubnetGroupRequestT = Model::CreateCacheSubnetGroupRequest>
        Model::CreateCacheSubnetGroupOutcomeCallable CreateCacheSubnetGroupCallable(const CreateCacheSubnetGroupRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::CreateCacheSubnetGroup, request);
        }
 
        template<typename CreateCacheSubnetGroupRequestT = Model::CreateCacheSubnetGroupRequest>
        void CreateCacheSubnetGroupAsync(const CreateCacheSubnetGroupRequestT& request, const CreateCacheSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::CreateCacheSubnetGroup, request, handler, context);
        }
 
        virtual Model::CreateGlobalReplicationGroupOutcome CreateGlobalReplicationGroup(const Model::CreateGlobalReplicationGroupRequest& request) const;
 
        template<typename CreateGlobalReplicationGroupRequestT = Model::CreateGlobalReplicationGroupRequest>
        Model::CreateGlobalReplicationGroupOutcomeCallable CreateGlobalReplicationGroupCallable(const CreateGlobalReplicationGroupRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::CreateGlobalReplicationGroup, request);
        }
 
        template<typename CreateGlobalReplicationGroupRequestT = Model::CreateGlobalReplicationGroupRequest>
        void CreateGlobalReplicationGroupAsync(const CreateGlobalReplicationGroupRequestT& request, const CreateGlobalReplicationGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::CreateGlobalReplicationGroup, request, handler, context);
        }
 
        virtual Model::CreateReplicationGroupOutcome CreateReplicationGroup(const Model::CreateReplicationGroupRequest& request) const;
 
        template<typename CreateReplicationGroupRequestT = Model::CreateReplicationGroupRequest>
        Model::CreateReplicationGroupOutcomeCallable CreateReplicationGroupCallable(const CreateReplicationGroupRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::CreateReplicationGroup, request);
        }
 
        template<typename CreateReplicationGroupRequestT = Model::CreateReplicationGroupRequest>
        void CreateReplicationGroupAsync(const CreateReplicationGroupRequestT& request, const CreateReplicationGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::CreateReplicationGroup, request, handler, context);
        }
 
        virtual Model::CreateServerlessCacheOutcome CreateServerlessCache(const Model::CreateServerlessCacheRequest& request) const;
 
        template<typename CreateServerlessCacheRequestT = Model::CreateServerlessCacheRequest>
        Model::CreateServerlessCacheOutcomeCallable CreateServerlessCacheCallable(const CreateServerlessCacheRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::CreateServerlessCache, request);
        }
 
        template<typename CreateServerlessCacheRequestT = Model::CreateServerlessCacheRequest>
        void CreateServerlessCacheAsync(const CreateServerlessCacheRequestT& request, const CreateServerlessCacheResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::CreateServerlessCache, request, handler, context);
        }
 
        virtual Model::CreateServerlessCacheSnapshotOutcome CreateServerlessCacheSnapshot(const Model::CreateServerlessCacheSnapshotRequest& request) const;
 
        template<typename CreateServerlessCacheSnapshotRequestT = Model::CreateServerlessCacheSnapshotRequest>
        Model::CreateServerlessCacheSnapshotOutcomeCallable CreateServerlessCacheSnapshotCallable(const CreateServerlessCacheSnapshotRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::CreateServerlessCacheSnapshot, request);
        }
 
        template<typename CreateServerlessCacheSnapshotRequestT = Model::CreateServerlessCacheSnapshotRequest>
        void CreateServerlessCacheSnapshotAsync(const CreateServerlessCacheSnapshotRequestT& request, const CreateServerlessCacheSnapshotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::CreateServerlessCacheSnapshot, request, handler, context);
        }
 
        virtual Model::CreateSnapshotOutcome CreateSnapshot(const Model::CreateSnapshotRequest& request) const;
 
        template<typename CreateSnapshotRequestT = Model::CreateSnapshotRequest>
        Model::CreateSnapshotOutcomeCallable CreateSnapshotCallable(const CreateSnapshotRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::CreateSnapshot, request);
        }
 
        template<typename CreateSnapshotRequestT = Model::CreateSnapshotRequest>
        void CreateSnapshotAsync(const CreateSnapshotRequestT& request, const CreateSnapshotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::CreateSnapshot, request, handler, context);
        }
 
        virtual Model::CreateUserOutcome CreateUser(const Model::CreateUserRequest& request) const;
 
        template<typename CreateUserRequestT = Model::CreateUserRequest>
        Model::CreateUserOutcomeCallable CreateUserCallable(const CreateUserRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::CreateUser, request);
        }
 
        template<typename CreateUserRequestT = Model::CreateUserRequest>
        void CreateUserAsync(const CreateUserRequestT& request, const CreateUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::CreateUser, request, handler, context);
        }
 
        virtual Model::CreateUserGroupOutcome CreateUserGroup(const Model::CreateUserGroupRequest& request) const;
 
        template<typename CreateUserGroupRequestT = Model::CreateUserGroupRequest>
        Model::CreateUserGroupOutcomeCallable CreateUserGroupCallable(const CreateUserGroupRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::CreateUserGroup, request);
        }
 
        template<typename CreateUserGroupRequestT = Model::CreateUserGroupRequest>
        void CreateUserGroupAsync(const CreateUserGroupRequestT& request, const CreateUserGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::CreateUserGroup, request, handler, context);
        }
 
        virtual Model::DecreaseNodeGroupsInGlobalReplicationGroupOutcome DecreaseNodeGroupsInGlobalReplicationGroup(const Model::DecreaseNodeGroupsInGlobalReplicationGroupRequest& request) const;
 
        template<typename DecreaseNodeGroupsInGlobalReplicationGroupRequestT = Model::DecreaseNodeGroupsInGlobalReplicationGroupRequest>
        Model::DecreaseNodeGroupsInGlobalReplicationGroupOutcomeCallable DecreaseNodeGroupsInGlobalReplicationGroupCallable(const DecreaseNodeGroupsInGlobalReplicationGroupRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::DecreaseNodeGroupsInGlobalReplicationGroup, request);
        }
 
        template<typename DecreaseNodeGroupsInGlobalReplicationGroupRequestT = Model::DecreaseNodeGroupsInGlobalReplicationGroupRequest>
        void DecreaseNodeGroupsInGlobalReplicationGroupAsync(const DecreaseNodeGroupsInGlobalReplicationGroupRequestT& request, const DecreaseNodeGroupsInGlobalReplicationGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::DecreaseNodeGroupsInGlobalReplicationGroup, request, handler, context);
        }
 
        virtual Model::DecreaseReplicaCountOutcome DecreaseReplicaCount(const Model::DecreaseReplicaCountRequest& request) const;
 
        template<typename DecreaseReplicaCountRequestT = Model::DecreaseReplicaCountRequest>
        Model::DecreaseReplicaCountOutcomeCallable DecreaseReplicaCountCallable(const DecreaseReplicaCountRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::DecreaseReplicaCount, request);
        }
 
        template<typename DecreaseReplicaCountRequestT = Model::DecreaseReplicaCountRequest>
        void DecreaseReplicaCountAsync(const DecreaseReplicaCountRequestT& request, const DecreaseReplicaCountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::DecreaseReplicaCount, request, handler, context);
        }
 
        virtual Model::DeleteCacheClusterOutcome DeleteCacheCluster(const Model::DeleteCacheClusterRequest& request) const;
 
        template<typename DeleteCacheClusterRequestT = Model::DeleteCacheClusterRequest>
        Model::DeleteCacheClusterOutcomeCallable DeleteCacheClusterCallable(const DeleteCacheClusterRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::DeleteCacheCluster, request);
        }
 
        template<typename DeleteCacheClusterRequestT = Model::DeleteCacheClusterRequest>
        void DeleteCacheClusterAsync(const DeleteCacheClusterRequestT& request, const DeleteCacheClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::DeleteCacheCluster, request, handler, context);
        }
 
        virtual Model::DeleteCacheParameterGroupOutcome DeleteCacheParameterGroup(const Model::DeleteCacheParameterGroupRequest& request) const;
 
        template<typename DeleteCacheParameterGroupRequestT = Model::DeleteCacheParameterGroupRequest>
        Model::DeleteCacheParameterGroupOutcomeCallable DeleteCacheParameterGroupCallable(const DeleteCacheParameterGroupRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::DeleteCacheParameterGroup, request);
        }
 
        template<typename DeleteCacheParameterGroupRequestT = Model::DeleteCacheParameterGroupRequest>
        void DeleteCacheParameterGroupAsync(const DeleteCacheParameterGroupRequestT& request, const DeleteCacheParameterGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::DeleteCacheParameterGroup, request, handler, context);
        }
 
        virtual Model::DeleteCacheSecurityGroupOutcome DeleteCacheSecurityGroup(const Model::DeleteCacheSecurityGroupRequest& request) const;
 
        template<typename DeleteCacheSecurityGroupRequestT = Model::DeleteCacheSecurityGroupRequest>
        Model::DeleteCacheSecurityGroupOutcomeCallable DeleteCacheSecurityGroupCallable(const DeleteCacheSecurityGroupRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::DeleteCacheSecurityGroup, request);
        }
 
        template<typename DeleteCacheSecurityGroupRequestT = Model::DeleteCacheSecurityGroupRequest>
        void DeleteCacheSecurityGroupAsync(const DeleteCacheSecurityGroupRequestT& request, const DeleteCacheSecurityGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::DeleteCacheSecurityGroup, request, handler, context);
        }
 
        virtual Model::DeleteCacheSubnetGroupOutcome DeleteCacheSubnetGroup(const Model::DeleteCacheSubnetGroupRequest& request) const;
 
        template<typename DeleteCacheSubnetGroupRequestT = Model::DeleteCacheSubnetGroupRequest>
        Model::DeleteCacheSubnetGroupOutcomeCallable DeleteCacheSubnetGroupCallable(const DeleteCacheSubnetGroupRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::DeleteCacheSubnetGroup, request);
        }
 
        template<typename DeleteCacheSubnetGroupRequestT = Model::DeleteCacheSubnetGroupRequest>
        void DeleteCacheSubnetGroupAsync(const DeleteCacheSubnetGroupRequestT& request, const DeleteCacheSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::DeleteCacheSubnetGroup, request, handler, context);
        }
 
        virtual Model::DeleteGlobalReplicationGroupOutcome DeleteGlobalReplicationGroup(const Model::DeleteGlobalReplicationGroupRequest& request) const;
 
        template<typename DeleteGlobalReplicationGroupRequestT = Model::DeleteGlobalReplicationGroupRequest>
        Model::DeleteGlobalReplicationGroupOutcomeCallable DeleteGlobalReplicationGroupCallable(const DeleteGlobalReplicationGroupRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::DeleteGlobalReplicationGroup, request);
        }
 
        template<typename DeleteGlobalReplicationGroupRequestT = Model::DeleteGlobalReplicationGroupRequest>
        void DeleteGlobalReplicationGroupAsync(const DeleteGlobalReplicationGroupRequestT& request, const DeleteGlobalReplicationGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::DeleteGlobalReplicationGroup, request, handler, context);
        }
 
        virtual Model::DeleteReplicationGroupOutcome DeleteReplicationGroup(const Model::DeleteReplicationGroupRequest& request) const;
 
        template<typename DeleteReplicationGroupRequestT = Model::DeleteReplicationGroupRequest>
        Model::DeleteReplicationGroupOutcomeCallable DeleteReplicationGroupCallable(const DeleteReplicationGroupRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::DeleteReplicationGroup, request);
        }
 
        template<typename DeleteReplicationGroupRequestT = Model::DeleteReplicationGroupRequest>
        void DeleteReplicationGroupAsync(const DeleteReplicationGroupRequestT& request, const DeleteReplicationGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::DeleteReplicationGroup, request, handler, context);
        }
 
        virtual Model::DeleteServerlessCacheOutcome DeleteServerlessCache(const Model::DeleteServerlessCacheRequest& request) const;
 
        template<typename DeleteServerlessCacheRequestT = Model::DeleteServerlessCacheRequest>
        Model::DeleteServerlessCacheOutcomeCallable DeleteServerlessCacheCallable(const DeleteServerlessCacheRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::DeleteServerlessCache, request);
        }
 
        template<typename DeleteServerlessCacheRequestT = Model::DeleteServerlessCacheRequest>
        void DeleteServerlessCacheAsync(const DeleteServerlessCacheRequestT& request, const DeleteServerlessCacheResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::DeleteServerlessCache, request, handler, context);
        }
 
        virtual Model::DeleteServerlessCacheSnapshotOutcome DeleteServerlessCacheSnapshot(const Model::DeleteServerlessCacheSnapshotRequest& request) const;
 
        template<typename DeleteServerlessCacheSnapshotRequestT = Model::DeleteServerlessCacheSnapshotRequest>
        Model::DeleteServerlessCacheSnapshotOutcomeCallable DeleteServerlessCacheSnapshotCallable(const DeleteServerlessCacheSnapshotRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::DeleteServerlessCacheSnapshot, request);
        }
 
        template<typename DeleteServerlessCacheSnapshotRequestT = Model::DeleteServerlessCacheSnapshotRequest>
        void DeleteServerlessCacheSnapshotAsync(const DeleteServerlessCacheSnapshotRequestT& request, const DeleteServerlessCacheSnapshotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::DeleteServerlessCacheSnapshot, request, handler, context);
        }
 
        virtual Model::DeleteSnapshotOutcome DeleteSnapshot(const Model::DeleteSnapshotRequest& request) const;
 
        template<typename DeleteSnapshotRequestT = Model::DeleteSnapshotRequest>
        Model::DeleteSnapshotOutcomeCallable DeleteSnapshotCallable(const DeleteSnapshotRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::DeleteSnapshot, request);
        }
 
        template<typename DeleteSnapshotRequestT = Model::DeleteSnapshotRequest>
        void DeleteSnapshotAsync(const DeleteSnapshotRequestT& request, const DeleteSnapshotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::DeleteSnapshot, request, handler, context);
        }
 
        virtual Model::DeleteUserOutcome DeleteUser(const Model::DeleteUserRequest& request) const;
 
        template<typename DeleteUserRequestT = Model::DeleteUserRequest>
        Model::DeleteUserOutcomeCallable DeleteUserCallable(const DeleteUserRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::DeleteUser, request);
        }
 
        template<typename DeleteUserRequestT = Model::DeleteUserRequest>
        void DeleteUserAsync(const DeleteUserRequestT& request, const DeleteUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::DeleteUser, request, handler, context);
        }
 
        virtual Model::DeleteUserGroupOutcome DeleteUserGroup(const Model::DeleteUserGroupRequest& request) const;
 
        template<typename DeleteUserGroupRequestT = Model::DeleteUserGroupRequest>
        Model::DeleteUserGroupOutcomeCallable DeleteUserGroupCallable(const DeleteUserGroupRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::DeleteUserGroup, request);
        }
 
        template<typename DeleteUserGroupRequestT = Model::DeleteUserGroupRequest>
        void DeleteUserGroupAsync(const DeleteUserGroupRequestT& request, const DeleteUserGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::DeleteUserGroup, request, handler, context);
        }
 
        virtual Model::DescribeCacheClustersOutcome DescribeCacheClusters(const Model::DescribeCacheClustersRequest& request = {}) const;
 
        template<typename DescribeCacheClustersRequestT = Model::DescribeCacheClustersRequest>
        Model::DescribeCacheClustersOutcomeCallable DescribeCacheClustersCallable(const DescribeCacheClustersRequestT& request = {}) const
        {
            return SubmitCallable(&ElastiCacheClient::DescribeCacheClusters, request);
        }
 
        template<typename DescribeCacheClustersRequestT = Model::DescribeCacheClustersRequest>
        void DescribeCacheClustersAsync(const DescribeCacheClustersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeCacheClustersRequestT& request = {}) const
        {
            return SubmitAsync(&ElastiCacheClient::DescribeCacheClusters, request, handler, context);
        }
 
        virtual Model::DescribeCacheEngineVersionsOutcome DescribeCacheEngineVersions(const Model::DescribeCacheEngineVersionsRequest& request = {}) const;
 
        template<typename DescribeCacheEngineVersionsRequestT = Model::DescribeCacheEngineVersionsRequest>
        Model::DescribeCacheEngineVersionsOutcomeCallable DescribeCacheEngineVersionsCallable(const DescribeCacheEngineVersionsRequestT& request = {}) const
        {
            return SubmitCallable(&ElastiCacheClient::DescribeCacheEngineVersions, request);
        }
 
        template<typename DescribeCacheEngineVersionsRequestT = Model::DescribeCacheEngineVersionsRequest>
        void DescribeCacheEngineVersionsAsync(const DescribeCacheEngineVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeCacheEngineVersionsRequestT& request = {}) const
        {
            return SubmitAsync(&ElastiCacheClient::DescribeCacheEngineVersions, request, handler, context);
        }
 
        virtual Model::DescribeCacheParameterGroupsOutcome DescribeCacheParameterGroups(const Model::DescribeCacheParameterGroupsRequest& request = {}) const;
 
        template<typename DescribeCacheParameterGroupsRequestT = Model::DescribeCacheParameterGroupsRequest>
        Model::DescribeCacheParameterGroupsOutcomeCallable DescribeCacheParameterGroupsCallable(const DescribeCacheParameterGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&ElastiCacheClient::DescribeCacheParameterGroups, request);
        }
 
        template<typename DescribeCacheParameterGroupsRequestT = Model::DescribeCacheParameterGroupsRequest>
        void DescribeCacheParameterGroupsAsync(const DescribeCacheParameterGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeCacheParameterGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&ElastiCacheClient::DescribeCacheParameterGroups, request, handler, context);
        }
 
        virtual Model::DescribeCacheParametersOutcome DescribeCacheParameters(const Model::DescribeCacheParametersRequest& request) const;
 
        template<typename DescribeCacheParametersRequestT = Model::DescribeCacheParametersRequest>
        Model::DescribeCacheParametersOutcomeCallable DescribeCacheParametersCallable(const DescribeCacheParametersRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::DescribeCacheParameters, request);
        }
 
        template<typename DescribeCacheParametersRequestT = Model::DescribeCacheParametersRequest>
        void DescribeCacheParametersAsync(const DescribeCacheParametersRequestT& request, const DescribeCacheParametersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::DescribeCacheParameters, request, handler, context);
        }
 
        virtual Model::DescribeCacheSecurityGroupsOutcome DescribeCacheSecurityGroups(const Model::DescribeCacheSecurityGroupsRequest& request = {}) const;
 
        template<typename DescribeCacheSecurityGroupsRequestT = Model::DescribeCacheSecurityGroupsRequest>
        Model::DescribeCacheSecurityGroupsOutcomeCallable DescribeCacheSecurityGroupsCallable(const DescribeCacheSecurityGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&ElastiCacheClient::DescribeCacheSecurityGroups, request);
        }
 
        template<typename DescribeCacheSecurityGroupsRequestT = Model::DescribeCacheSecurityGroupsRequest>
        void DescribeCacheSecurityGroupsAsync(const DescribeCacheSecurityGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeCacheSecurityGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&ElastiCacheClient::DescribeCacheSecurityGroups, request, handler, context);
        }
 
        virtual Model::DescribeCacheSubnetGroupsOutcome DescribeCacheSubnetGroups(const Model::DescribeCacheSubnetGroupsRequest& request = {}) const;
 
        template<typename DescribeCacheSubnetGroupsRequestT = Model::DescribeCacheSubnetGroupsRequest>
        Model::DescribeCacheSubnetGroupsOutcomeCallable DescribeCacheSubnetGroupsCallable(const DescribeCacheSubnetGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&ElastiCacheClient::DescribeCacheSubnetGroups, request);
        }
 
        template<typename DescribeCacheSubnetGroupsRequestT = Model::DescribeCacheSubnetGroupsRequest>
        void DescribeCacheSubnetGroupsAsync(const DescribeCacheSubnetGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeCacheSubnetGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&ElastiCacheClient::DescribeCacheSubnetGroups, request, handler, context);
        }
 
        virtual Model::DescribeEngineDefaultParametersOutcome DescribeEngineDefaultParameters(const Model::DescribeEngineDefaultParametersRequest& request) const;
 
        template<typename DescribeEngineDefaultParametersRequestT = Model::DescribeEngineDefaultParametersRequest>
        Model::DescribeEngineDefaultParametersOutcomeCallable DescribeEngineDefaultParametersCallable(const DescribeEngineDefaultParametersRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::DescribeEngineDefaultParameters, request);
        }
 
        template<typename DescribeEngineDefaultParametersRequestT = Model::DescribeEngineDefaultParametersRequest>
        void DescribeEngineDefaultParametersAsync(const DescribeEngineDefaultParametersRequestT& request, const DescribeEngineDefaultParametersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::DescribeEngineDefaultParameters, request, handler, context);
        }
 
        virtual Model::DescribeEventsOutcome DescribeEvents(const Model::DescribeEventsRequest& request = {}) const;
 
        template<typename DescribeEventsRequestT = Model::DescribeEventsRequest>
        Model::DescribeEventsOutcomeCallable DescribeEventsCallable(const DescribeEventsRequestT& request = {}) const
        {
            return SubmitCallable(&ElastiCacheClient::DescribeEvents, request);
        }
 
        template<typename DescribeEventsRequestT = Model::DescribeEventsRequest>
        void DescribeEventsAsync(const DescribeEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeEventsRequestT& request = {}) const
        {
            return SubmitAsync(&ElastiCacheClient::DescribeEvents, request, handler, context);
        }
 
        virtual Model::DescribeGlobalReplicationGroupsOutcome DescribeGlobalReplicationGroups(const Model::DescribeGlobalReplicationGroupsRequest& request = {}) const;
 
        template<typename DescribeGlobalReplicationGroupsRequestT = Model::DescribeGlobalReplicationGroupsRequest>
        Model::DescribeGlobalReplicationGroupsOutcomeCallable DescribeGlobalReplicationGroupsCallable(const DescribeGlobalReplicationGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&ElastiCacheClient::DescribeGlobalReplicationGroups, request);
        }
 
        template<typename DescribeGlobalReplicationGroupsRequestT = Model::DescribeGlobalReplicationGroupsRequest>
        void DescribeGlobalReplicationGroupsAsync(const DescribeGlobalReplicationGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeGlobalReplicationGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&ElastiCacheClient::DescribeGlobalReplicationGroups, request, handler, context);
        }
 
        virtual Model::DescribeReplicationGroupsOutcome DescribeReplicationGroups(const Model::DescribeReplicationGroupsRequest& request = {}) const;
 
        template<typename DescribeReplicationGroupsRequestT = Model::DescribeReplicationGroupsRequest>
        Model::DescribeReplicationGroupsOutcomeCallable DescribeReplicationGroupsCallable(const DescribeReplicationGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&ElastiCacheClient::DescribeReplicationGroups, request);
        }
 
        template<typename DescribeReplicationGroupsRequestT = Model::DescribeReplicationGroupsRequest>
        void DescribeReplicationGroupsAsync(const DescribeReplicationGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeReplicationGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&ElastiCacheClient::DescribeReplicationGroups, request, handler, context);
        }
 
        virtual Model::DescribeReservedCacheNodesOutcome DescribeReservedCacheNodes(const Model::DescribeReservedCacheNodesRequest& request = {}) const;
 
        template<typename DescribeReservedCacheNodesRequestT = Model::DescribeReservedCacheNodesRequest>
        Model::DescribeReservedCacheNodesOutcomeCallable DescribeReservedCacheNodesCallable(const DescribeReservedCacheNodesRequestT& request = {}) const
        {
            return SubmitCallable(&ElastiCacheClient::DescribeReservedCacheNodes, request);
        }
 
        template<typename DescribeReservedCacheNodesRequestT = Model::DescribeReservedCacheNodesRequest>
        void DescribeReservedCacheNodesAsync(const DescribeReservedCacheNodesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeReservedCacheNodesRequestT& request = {}) const
        {
            return SubmitAsync(&ElastiCacheClient::DescribeReservedCacheNodes, request, handler, context);
        }
 
        virtual Model::DescribeReservedCacheNodesOfferingsOutcome DescribeReservedCacheNodesOfferings(const Model::DescribeReservedCacheNodesOfferingsRequest& request = {}) const;
 
        template<typename DescribeReservedCacheNodesOfferingsRequestT = Model::DescribeReservedCacheNodesOfferingsRequest>
        Model::DescribeReservedCacheNodesOfferingsOutcomeCallable DescribeReservedCacheNodesOfferingsCallable(const DescribeReservedCacheNodesOfferingsRequestT& request = {}) const
        {
            return SubmitCallable(&ElastiCacheClient::DescribeReservedCacheNodesOfferings, request);
        }
 
        template<typename DescribeReservedCacheNodesOfferingsRequestT = Model::DescribeReservedCacheNodesOfferingsRequest>
        void DescribeReservedCacheNodesOfferingsAsync(const DescribeReservedCacheNodesOfferingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeReservedCacheNodesOfferingsRequestT& request = {}) const
        {
            return SubmitAsync(&ElastiCacheClient::DescribeReservedCacheNodesOfferings, request, handler, context);
        }
 
        virtual Model::DescribeServerlessCacheSnapshotsOutcome DescribeServerlessCacheSnapshots(const Model::DescribeServerlessCacheSnapshotsRequest& request = {}) const;
 
        template<typename DescribeServerlessCacheSnapshotsRequestT = Model::DescribeServerlessCacheSnapshotsRequest>
        Model::DescribeServerlessCacheSnapshotsOutcomeCallable DescribeServerlessCacheSnapshotsCallable(const DescribeServerlessCacheSnapshotsRequestT& request = {}) const
        {
            return SubmitCallable(&ElastiCacheClient::DescribeServerlessCacheSnapshots, request);
        }
 
        template<typename DescribeServerlessCacheSnapshotsRequestT = Model::DescribeServerlessCacheSnapshotsRequest>
        void DescribeServerlessCacheSnapshotsAsync(const DescribeServerlessCacheSnapshotsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeServerlessCacheSnapshotsRequestT& request = {}) const
        {
            return SubmitAsync(&ElastiCacheClient::DescribeServerlessCacheSnapshots, request, handler, context);
        }
 
        virtual Model::DescribeServerlessCachesOutcome DescribeServerlessCaches(const Model::DescribeServerlessCachesRequest& request = {}) const;
 
        template<typename DescribeServerlessCachesRequestT = Model::DescribeServerlessCachesRequest>
        Model::DescribeServerlessCachesOutcomeCallable DescribeServerlessCachesCallable(const DescribeServerlessCachesRequestT& request = {}) const
        {
            return SubmitCallable(&ElastiCacheClient::DescribeServerlessCaches, request);
        }
 
        template<typename DescribeServerlessCachesRequestT = Model::DescribeServerlessCachesRequest>
        void DescribeServerlessCachesAsync(const DescribeServerlessCachesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeServerlessCachesRequestT& request = {}) const
        {
            return SubmitAsync(&ElastiCacheClient::DescribeServerlessCaches, request, handler, context);
        }
 
        virtual Model::DescribeServiceUpdatesOutcome DescribeServiceUpdates(const Model::DescribeServiceUpdatesRequest& request = {}) const;
 
        template<typename DescribeServiceUpdatesRequestT = Model::DescribeServiceUpdatesRequest>
        Model::DescribeServiceUpdatesOutcomeCallable DescribeServiceUpdatesCallable(const DescribeServiceUpdatesRequestT& request = {}) const
        {
            return SubmitCallable(&ElastiCacheClient::DescribeServiceUpdates, request);
        }
 
        template<typename DescribeServiceUpdatesRequestT = Model::DescribeServiceUpdatesRequest>
        void DescribeServiceUpdatesAsync(const DescribeServiceUpdatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeServiceUpdatesRequestT& request = {}) const
        {
            return SubmitAsync(&ElastiCacheClient::DescribeServiceUpdates, request, handler, context);
        }
 
        virtual Model::DescribeSnapshotsOutcome DescribeSnapshots(const Model::DescribeSnapshotsRequest& request = {}) const;
 
        template<typename DescribeSnapshotsRequestT = Model::DescribeSnapshotsRequest>
        Model::DescribeSnapshotsOutcomeCallable DescribeSnapshotsCallable(const DescribeSnapshotsRequestT& request = {}) const
        {
            return SubmitCallable(&ElastiCacheClient::DescribeSnapshots, request);
        }
 
        template<typename DescribeSnapshotsRequestT = Model::DescribeSnapshotsRequest>
        void DescribeSnapshotsAsync(const DescribeSnapshotsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeSnapshotsRequestT& request = {}) const
        {
            return SubmitAsync(&ElastiCacheClient::DescribeSnapshots, request, handler, context);
        }
 
        virtual Model::DescribeUpdateActionsOutcome DescribeUpdateActions(const Model::DescribeUpdateActionsRequest& request = {}) const;
 
        template<typename DescribeUpdateActionsRequestT = Model::DescribeUpdateActionsRequest>
        Model::DescribeUpdateActionsOutcomeCallable DescribeUpdateActionsCallable(const DescribeUpdateActionsRequestT& request = {}) const
        {
            return SubmitCallable(&ElastiCacheClient::DescribeUpdateActions, request);
        }
 
        template<typename DescribeUpdateActionsRequestT = Model::DescribeUpdateActionsRequest>
        void DescribeUpdateActionsAsync(const DescribeUpdateActionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeUpdateActionsRequestT& request = {}) const
        {
            return SubmitAsync(&ElastiCacheClient::DescribeUpdateActions, request, handler, context);
        }
 
        virtual Model::DescribeUserGroupsOutcome DescribeUserGroups(const Model::DescribeUserGroupsRequest& request = {}) const;
 
        template<typename DescribeUserGroupsRequestT = Model::DescribeUserGroupsRequest>
        Model::DescribeUserGroupsOutcomeCallable DescribeUserGroupsCallable(const DescribeUserGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&ElastiCacheClient::DescribeUserGroups, request);
        }
 
        template<typename DescribeUserGroupsRequestT = Model::DescribeUserGroupsRequest>
        void DescribeUserGroupsAsync(const DescribeUserGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeUserGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&ElastiCacheClient::DescribeUserGroups, request, handler, context);
        }
 
        virtual Model::DescribeUsersOutcome DescribeUsers(const Model::DescribeUsersRequest& request = {}) const;
 
        template<typename DescribeUsersRequestT = Model::DescribeUsersRequest>
        Model::DescribeUsersOutcomeCallable DescribeUsersCallable(const DescribeUsersRequestT& request = {}) const
        {
            return SubmitCallable(&ElastiCacheClient::DescribeUsers, request);
        }
 
        template<typename DescribeUsersRequestT = Model::DescribeUsersRequest>
        void DescribeUsersAsync(const DescribeUsersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeUsersRequestT& request = {}) const
        {
            return SubmitAsync(&ElastiCacheClient::DescribeUsers, request, handler, context);
        }
 
        virtual Model::DisassociateGlobalReplicationGroupOutcome DisassociateGlobalReplicationGroup(const Model::DisassociateGlobalReplicationGroupRequest& request) const;
 
        template<typename DisassociateGlobalReplicationGroupRequestT = Model::DisassociateGlobalReplicationGroupRequest>
        Model::DisassociateGlobalReplicationGroupOutcomeCallable DisassociateGlobalReplicationGroupCallable(const DisassociateGlobalReplicationGroupRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::DisassociateGlobalReplicationGroup, request);
        }
 
        template<typename DisassociateGlobalReplicationGroupRequestT = Model::DisassociateGlobalReplicationGroupRequest>
        void DisassociateGlobalReplicationGroupAsync(const DisassociateGlobalReplicationGroupRequestT& request, const DisassociateGlobalReplicationGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::DisassociateGlobalReplicationGroup, request, handler, context);
        }
 
        virtual Model::ExportServerlessCacheSnapshotOutcome ExportServerlessCacheSnapshot(const Model::ExportServerlessCacheSnapshotRequest& request) const;
 
        template<typename ExportServerlessCacheSnapshotRequestT = Model::ExportServerlessCacheSnapshotRequest>
        Model::ExportServerlessCacheSnapshotOutcomeCallable ExportServerlessCacheSnapshotCallable(const ExportServerlessCacheSnapshotRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::ExportServerlessCacheSnapshot, request);
        }
 
        template<typename ExportServerlessCacheSnapshotRequestT = Model::ExportServerlessCacheSnapshotRequest>
        void ExportServerlessCacheSnapshotAsync(const ExportServerlessCacheSnapshotRequestT& request, const ExportServerlessCacheSnapshotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::ExportServerlessCacheSnapshot, request, handler, context);
        }
 
        virtual Model::FailoverGlobalReplicationGroupOutcome FailoverGlobalReplicationGroup(const Model::FailoverGlobalReplicationGroupRequest& request) const;
 
        template<typename FailoverGlobalReplicationGroupRequestT = Model::FailoverGlobalReplicationGroupRequest>
        Model::FailoverGlobalReplicationGroupOutcomeCallable FailoverGlobalReplicationGroupCallable(const FailoverGlobalReplicationGroupRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::FailoverGlobalReplicationGroup, request);
        }
 
        template<typename FailoverGlobalReplicationGroupRequestT = Model::FailoverGlobalReplicationGroupRequest>
        void FailoverGlobalReplicationGroupAsync(const FailoverGlobalReplicationGroupRequestT& request, const FailoverGlobalReplicationGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::FailoverGlobalReplicationGroup, request, handler, context);
        }
 
        virtual Model::IncreaseNodeGroupsInGlobalReplicationGroupOutcome IncreaseNodeGroupsInGlobalReplicationGroup(const Model::IncreaseNodeGroupsInGlobalReplicationGroupRequest& request) const;
 
        template<typename IncreaseNodeGroupsInGlobalReplicationGroupRequestT = Model::IncreaseNodeGroupsInGlobalReplicationGroupRequest>
        Model::IncreaseNodeGroupsInGlobalReplicationGroupOutcomeCallable IncreaseNodeGroupsInGlobalReplicationGroupCallable(const IncreaseNodeGroupsInGlobalReplicationGroupRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::IncreaseNodeGroupsInGlobalReplicationGroup, request);
        }
 
        template<typename IncreaseNodeGroupsInGlobalReplicationGroupRequestT = Model::IncreaseNodeGroupsInGlobalReplicationGroupRequest>
        void IncreaseNodeGroupsInGlobalReplicationGroupAsync(const IncreaseNodeGroupsInGlobalReplicationGroupRequestT& request, const IncreaseNodeGroupsInGlobalReplicationGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::IncreaseNodeGroupsInGlobalReplicationGroup, request, handler, context);
        }
 
        virtual Model::IncreaseReplicaCountOutcome IncreaseReplicaCount(const Model::IncreaseReplicaCountRequest& request) const;
 
        template<typename IncreaseReplicaCountRequestT = Model::IncreaseReplicaCountRequest>
        Model::IncreaseReplicaCountOutcomeCallable IncreaseReplicaCountCallable(const IncreaseReplicaCountRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::IncreaseReplicaCount, request);
        }
 
        template<typename IncreaseReplicaCountRequestT = Model::IncreaseReplicaCountRequest>
        void IncreaseReplicaCountAsync(const IncreaseReplicaCountRequestT& request, const IncreaseReplicaCountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::IncreaseReplicaCount, request, handler, context);
        }
 
        virtual Model::ListAllowedNodeTypeModificationsOutcome ListAllowedNodeTypeModifications(const Model::ListAllowedNodeTypeModificationsRequest& request = {}) const;
 
        template<typename ListAllowedNodeTypeModificationsRequestT = Model::ListAllowedNodeTypeModificationsRequest>
        Model::ListAllowedNodeTypeModificationsOutcomeCallable ListAllowedNodeTypeModificationsCallable(const ListAllowedNodeTypeModificationsRequestT& request = {}) const
        {
            return SubmitCallable(&ElastiCacheClient::ListAllowedNodeTypeModifications, request);
        }
 
        template<typename ListAllowedNodeTypeModificationsRequestT = Model::ListAllowedNodeTypeModificationsRequest>
        void ListAllowedNodeTypeModificationsAsync(const ListAllowedNodeTypeModificationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAllowedNodeTypeModificationsRequestT& request = {}) const
        {
            return SubmitAsync(&ElastiCacheClient::ListAllowedNodeTypeModifications, 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(&ElastiCacheClient::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(&ElastiCacheClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ModifyCacheClusterOutcome ModifyCacheCluster(const Model::ModifyCacheClusterRequest& request) const;
 
        template<typename ModifyCacheClusterRequestT = Model::ModifyCacheClusterRequest>
        Model::ModifyCacheClusterOutcomeCallable ModifyCacheClusterCallable(const ModifyCacheClusterRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::ModifyCacheCluster, request);
        }
 
        template<typename ModifyCacheClusterRequestT = Model::ModifyCacheClusterRequest>
        void ModifyCacheClusterAsync(const ModifyCacheClusterRequestT& request, const ModifyCacheClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::ModifyCacheCluster, request, handler, context);
        }
 
        virtual Model::ModifyCacheParameterGroupOutcome ModifyCacheParameterGroup(const Model::ModifyCacheParameterGroupRequest& request) const;
 
        template<typename ModifyCacheParameterGroupRequestT = Model::ModifyCacheParameterGroupRequest>
        Model::ModifyCacheParameterGroupOutcomeCallable ModifyCacheParameterGroupCallable(const ModifyCacheParameterGroupRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::ModifyCacheParameterGroup, request);
        }
 
        template<typename ModifyCacheParameterGroupRequestT = Model::ModifyCacheParameterGroupRequest>
        void ModifyCacheParameterGroupAsync(const ModifyCacheParameterGroupRequestT& request, const ModifyCacheParameterGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::ModifyCacheParameterGroup, request, handler, context);
        }
 
        virtual Model::ModifyCacheSubnetGroupOutcome ModifyCacheSubnetGroup(const Model::ModifyCacheSubnetGroupRequest& request) const;
 
        template<typename ModifyCacheSubnetGroupRequestT = Model::ModifyCacheSubnetGroupRequest>
        Model::ModifyCacheSubnetGroupOutcomeCallable ModifyCacheSubnetGroupCallable(const ModifyCacheSubnetGroupRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::ModifyCacheSubnetGroup, request);
        }
 
        template<typename ModifyCacheSubnetGroupRequestT = Model::ModifyCacheSubnetGroupRequest>
        void ModifyCacheSubnetGroupAsync(const ModifyCacheSubnetGroupRequestT& request, const ModifyCacheSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::ModifyCacheSubnetGroup, request, handler, context);
        }
 
        virtual Model::ModifyGlobalReplicationGroupOutcome ModifyGlobalReplicationGroup(const Model::ModifyGlobalReplicationGroupRequest& request) const;
 
        template<typename ModifyGlobalReplicationGroupRequestT = Model::ModifyGlobalReplicationGroupRequest>
        Model::ModifyGlobalReplicationGroupOutcomeCallable ModifyGlobalReplicationGroupCallable(const ModifyGlobalReplicationGroupRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::ModifyGlobalReplicationGroup, request);
        }
 
        template<typename ModifyGlobalReplicationGroupRequestT = Model::ModifyGlobalReplicationGroupRequest>
        void ModifyGlobalReplicationGroupAsync(const ModifyGlobalReplicationGroupRequestT& request, const ModifyGlobalReplicationGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::ModifyGlobalReplicationGroup, request, handler, context);
        }
 
        virtual Model::ModifyReplicationGroupOutcome ModifyReplicationGroup(const Model::ModifyReplicationGroupRequest& request) const;
 
        template<typename ModifyReplicationGroupRequestT = Model::ModifyReplicationGroupRequest>
        Model::ModifyReplicationGroupOutcomeCallable ModifyReplicationGroupCallable(const ModifyReplicationGroupRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::ModifyReplicationGroup, request);
        }
 
        template<typename ModifyReplicationGroupRequestT = Model::ModifyReplicationGroupRequest>
        void ModifyReplicationGroupAsync(const ModifyReplicationGroupRequestT& request, const ModifyReplicationGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::ModifyReplicationGroup, request, handler, context);
        }
 
        virtual Model::ModifyReplicationGroupShardConfigurationOutcome ModifyReplicationGroupShardConfiguration(const Model::ModifyReplicationGroupShardConfigurationRequest& request) const;
 
        template<typename ModifyReplicationGroupShardConfigurationRequestT = Model::ModifyReplicationGroupShardConfigurationRequest>
        Model::ModifyReplicationGroupShardConfigurationOutcomeCallable ModifyReplicationGroupShardConfigurationCallable(const ModifyReplicationGroupShardConfigurationRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::ModifyReplicationGroupShardConfiguration, request);
        }
 
        template<typename ModifyReplicationGroupShardConfigurationRequestT = Model::ModifyReplicationGroupShardConfigurationRequest>
        void ModifyReplicationGroupShardConfigurationAsync(const ModifyReplicationGroupShardConfigurationRequestT& request, const ModifyReplicationGroupShardConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::ModifyReplicationGroupShardConfiguration, request, handler, context);
        }
 
        virtual Model::ModifyServerlessCacheOutcome ModifyServerlessCache(const Model::ModifyServerlessCacheRequest& request) const;
 
        template<typename ModifyServerlessCacheRequestT = Model::ModifyServerlessCacheRequest>
        Model::ModifyServerlessCacheOutcomeCallable ModifyServerlessCacheCallable(const ModifyServerlessCacheRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::ModifyServerlessCache, request);
        }
 
        template<typename ModifyServerlessCacheRequestT = Model::ModifyServerlessCacheRequest>
        void ModifyServerlessCacheAsync(const ModifyServerlessCacheRequestT& request, const ModifyServerlessCacheResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::ModifyServerlessCache, request, handler, context);
        }
 
        virtual Model::ModifyUserOutcome ModifyUser(const Model::ModifyUserRequest& request) const;
 
        template<typename ModifyUserRequestT = Model::ModifyUserRequest>
        Model::ModifyUserOutcomeCallable ModifyUserCallable(const ModifyUserRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::ModifyUser, request);
        }
 
        template<typename ModifyUserRequestT = Model::ModifyUserRequest>
        void ModifyUserAsync(const ModifyUserRequestT& request, const ModifyUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::ModifyUser, request, handler, context);
        }
 
        virtual Model::ModifyUserGroupOutcome ModifyUserGroup(const Model::ModifyUserGroupRequest& request) const;
 
        template<typename ModifyUserGroupRequestT = Model::ModifyUserGroupRequest>
        Model::ModifyUserGroupOutcomeCallable ModifyUserGroupCallable(const ModifyUserGroupRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::ModifyUserGroup, request);
        }
 
        template<typename ModifyUserGroupRequestT = Model::ModifyUserGroupRequest>
        void ModifyUserGroupAsync(const ModifyUserGroupRequestT& request, const ModifyUserGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::ModifyUserGroup, request, handler, context);
        }
 
        virtual Model::PurchaseReservedCacheNodesOfferingOutcome PurchaseReservedCacheNodesOffering(const Model::PurchaseReservedCacheNodesOfferingRequest& request) const;
 
        template<typename PurchaseReservedCacheNodesOfferingRequestT = Model::PurchaseReservedCacheNodesOfferingRequest>
        Model::PurchaseReservedCacheNodesOfferingOutcomeCallable PurchaseReservedCacheNodesOfferingCallable(const PurchaseReservedCacheNodesOfferingRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::PurchaseReservedCacheNodesOffering, request);
        }
 
        template<typename PurchaseReservedCacheNodesOfferingRequestT = Model::PurchaseReservedCacheNodesOfferingRequest>
        void PurchaseReservedCacheNodesOfferingAsync(const PurchaseReservedCacheNodesOfferingRequestT& request, const PurchaseReservedCacheNodesOfferingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::PurchaseReservedCacheNodesOffering, request, handler, context);
        }
 
        virtual Model::RebalanceSlotsInGlobalReplicationGroupOutcome RebalanceSlotsInGlobalReplicationGroup(const Model::RebalanceSlotsInGlobalReplicationGroupRequest& request) const;
 
        template<typename RebalanceSlotsInGlobalReplicationGroupRequestT = Model::RebalanceSlotsInGlobalReplicationGroupRequest>
        Model::RebalanceSlotsInGlobalReplicationGroupOutcomeCallable RebalanceSlotsInGlobalReplicationGroupCallable(const RebalanceSlotsInGlobalReplicationGroupRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::RebalanceSlotsInGlobalReplicationGroup, request);
        }
 
        template<typename RebalanceSlotsInGlobalReplicationGroupRequestT = Model::RebalanceSlotsInGlobalReplicationGroupRequest>
        void RebalanceSlotsInGlobalReplicationGroupAsync(const RebalanceSlotsInGlobalReplicationGroupRequestT& request, const RebalanceSlotsInGlobalReplicationGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::RebalanceSlotsInGlobalReplicationGroup, request, handler, context);
        }
 
        virtual Model::RebootCacheClusterOutcome RebootCacheCluster(const Model::RebootCacheClusterRequest& request) const;
 
        template<typename RebootCacheClusterRequestT = Model::RebootCacheClusterRequest>
        Model::RebootCacheClusterOutcomeCallable RebootCacheClusterCallable(const RebootCacheClusterRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::RebootCacheCluster, request);
        }
 
        template<typename RebootCacheClusterRequestT = Model::RebootCacheClusterRequest>
        void RebootCacheClusterAsync(const RebootCacheClusterRequestT& request, const RebootCacheClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::RebootCacheCluster, request, handler, context);
        }
 
        virtual Model::RemoveTagsFromResourceOutcome RemoveTagsFromResource(const Model::RemoveTagsFromResourceRequest& request) const;
 
        template<typename RemoveTagsFromResourceRequestT = Model::RemoveTagsFromResourceRequest>
        Model::RemoveTagsFromResourceOutcomeCallable RemoveTagsFromResourceCallable(const RemoveTagsFromResourceRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::RemoveTagsFromResource, request);
        }
 
        template<typename RemoveTagsFromResourceRequestT = Model::RemoveTagsFromResourceRequest>
        void RemoveTagsFromResourceAsync(const RemoveTagsFromResourceRequestT& request, const RemoveTagsFromResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::RemoveTagsFromResource, request, handler, context);
        }
 
        virtual Model::ResetCacheParameterGroupOutcome ResetCacheParameterGroup(const Model::ResetCacheParameterGroupRequest& request) const;
 
        template<typename ResetCacheParameterGroupRequestT = Model::ResetCacheParameterGroupRequest>
        Model::ResetCacheParameterGroupOutcomeCallable ResetCacheParameterGroupCallable(const ResetCacheParameterGroupRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::ResetCacheParameterGroup, request);
        }
 
        template<typename ResetCacheParameterGroupRequestT = Model::ResetCacheParameterGroupRequest>
        void ResetCacheParameterGroupAsync(const ResetCacheParameterGroupRequestT& request, const ResetCacheParameterGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::ResetCacheParameterGroup, request, handler, context);
        }
 
        virtual Model::RevokeCacheSecurityGroupIngressOutcome RevokeCacheSecurityGroupIngress(const Model::RevokeCacheSecurityGroupIngressRequest& request) const;
 
        template<typename RevokeCacheSecurityGroupIngressRequestT = Model::RevokeCacheSecurityGroupIngressRequest>
        Model::RevokeCacheSecurityGroupIngressOutcomeCallable RevokeCacheSecurityGroupIngressCallable(const RevokeCacheSecurityGroupIngressRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::RevokeCacheSecurityGroupIngress, request);
        }
 
        template<typename RevokeCacheSecurityGroupIngressRequestT = Model::RevokeCacheSecurityGroupIngressRequest>
        void RevokeCacheSecurityGroupIngressAsync(const RevokeCacheSecurityGroupIngressRequestT& request, const RevokeCacheSecurityGroupIngressResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::RevokeCacheSecurityGroupIngress, request, handler, context);
        }
 
        virtual Model::StartMigrationOutcome StartMigration(const Model::StartMigrationRequest& request) const;
 
        template<typename StartMigrationRequestT = Model::StartMigrationRequest>
        Model::StartMigrationOutcomeCallable StartMigrationCallable(const StartMigrationRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::StartMigration, request);
        }
 
        template<typename StartMigrationRequestT = Model::StartMigrationRequest>
        void StartMigrationAsync(const StartMigrationRequestT& request, const StartMigrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::StartMigration, request, handler, context);
        }
 
        virtual Model::TestFailoverOutcome TestFailover(const Model::TestFailoverRequest& request) const;
 
        template<typename TestFailoverRequestT = Model::TestFailoverRequest>
        Model::TestFailoverOutcomeCallable TestFailoverCallable(const TestFailoverRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::TestFailover, request);
        }
 
        template<typename TestFailoverRequestT = Model::TestFailoverRequest>
        void TestFailoverAsync(const TestFailoverRequestT& request, const TestFailoverResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::TestFailover, request, handler, context);
        }
 
        virtual Model::TestMigrationOutcome TestMigration(const Model::TestMigrationRequest& request) const;
 
        template<typename TestMigrationRequestT = Model::TestMigrationRequest>
        Model::TestMigrationOutcomeCallable TestMigrationCallable(const TestMigrationRequestT& request) const
        {
            return SubmitCallable(&ElastiCacheClient::TestMigration, request);
        }
 
        template<typename TestMigrationRequestT = Model::TestMigrationRequest>
        void TestMigrationAsync(const TestMigrationRequestT& request, const TestMigrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElastiCacheClient::TestMigration, request, handler, context);
        }
 
 
        void OverrideEndpoint(const Aws::String& endpoint);
        std::shared_ptr<ElastiCacheEndpointProviderBase>& accessEndpointProvider();
  private:
        friend class Aws::Client::ClientWithAsyncTemplateMethods<ElastiCacheClient>;
        void init(const ElastiCacheClientConfiguration& clientConfiguration);
 
        ElastiCacheClientConfiguration m_clientConfiguration;
        std::shared_ptr<ElastiCacheEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace ElastiCache
} // namespace Aws