ElastiCacheClient.h

 
#pragma once
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/elasticache/ElastiCacheServiceClientModel.h>
#include <aws/elasticache/ElastiCache_EXPORTS.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