DynamoDBClient.h

 
#pragma once
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/dynamodb/DynamoDBErrorMarshaller.h>
#include <aws/dynamodb/DynamoDBPaginationBase.h>
#include <aws/dynamodb/DynamoDBServiceClientModel.h>
#include <aws/dynamodb/DynamoDB_EXPORTS.h>
#include <smithy/client/AwsSmithyClient.h>
#include <smithy/client/serializer/JsonOutcomeSerializer.h>
#include <smithy/identity/auth/built-in/GenericAuthSchemeResolver.h>
#include <smithy/identity/auth/built-in/SigV4AuthScheme.h>
 
namespace Aws {
namespace DynamoDB {
AWS_DYNAMODB_API extern const char SERVICE_NAME[];
class AWS_DYNAMODB_API DynamoDBClient
    : Aws::Client::ClientWithAsyncTemplateMethods<DynamoDBClient>,
      public smithy::client::AwsSmithyClientT<Aws::DynamoDB::SERVICE_NAME, Aws::DynamoDB::DynamoDBClientConfiguration,
                                              smithy::AuthSchemeResolverBase<>, Aws::Crt::Variant<smithy::SigV4AuthScheme>,
                                              DynamoDBEndpointProviderBase, smithy::client::JsonOutcomeSerializer,
                                              smithy::client::JsonOutcome, Aws::Client::DynamoDBErrorMarshaller>,
      public DynamoDBPaginationBase<DynamoDBClient> {
 public:
  static const char* GetServiceName();
  static const char* GetAllocationTag();
  inline const char* GetServiceClientName() const override { return "DynamoDB"; }
 
  typedef DynamoDBClientConfiguration ClientConfigurationType;
  typedef DynamoDBEndpointProvider EndpointProviderType;
 
  DynamoDBClient(const Aws::DynamoDB::DynamoDBClientConfiguration& clientConfiguration = Aws::DynamoDB::DynamoDBClientConfiguration(),
                 std::shared_ptr<DynamoDBEndpointProviderBase> endpointProvider = nullptr);
 
  DynamoDBClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<DynamoDBEndpointProviderBase> endpointProvider = nullptr,
                 const Aws::DynamoDB::DynamoDBClientConfiguration& clientConfiguration = Aws::DynamoDB::DynamoDBClientConfiguration());
 
  DynamoDBClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                 std::shared_ptr<DynamoDBEndpointProviderBase> endpointProvider = nullptr,
                 const Aws::DynamoDB::DynamoDBClientConfiguration& clientConfiguration = Aws::DynamoDB::DynamoDBClientConfiguration());
 
  /* Legacy constructors due deprecation */
  DynamoDBClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  DynamoDBClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  DynamoDBClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                 const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~DynamoDBClient();
 
  virtual Model::BatchExecuteStatementOutcome BatchExecuteStatement(const Model::BatchExecuteStatementRequest& request) const;
 
  template <typename BatchExecuteStatementRequestT = Model::BatchExecuteStatementRequest>
  Model::BatchExecuteStatementOutcomeCallable BatchExecuteStatementCallable(const BatchExecuteStatementRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::BatchExecuteStatement, request);
  }
 
  template <typename BatchExecuteStatementRequestT = Model::BatchExecuteStatementRequest>
  void BatchExecuteStatementAsync(const BatchExecuteStatementRequestT& request, const BatchExecuteStatementResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::BatchExecuteStatement, request, handler, context);
  }
 
  virtual Model::BatchGetItemOutcome BatchGetItem(const Model::BatchGetItemRequest& request) const;
 
  template <typename BatchGetItemRequestT = Model::BatchGetItemRequest>
  Model::BatchGetItemOutcomeCallable BatchGetItemCallable(const BatchGetItemRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::BatchGetItem, request);
  }
 
  template <typename BatchGetItemRequestT = Model::BatchGetItemRequest>
  void BatchGetItemAsync(const BatchGetItemRequestT& request, const BatchGetItemResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::BatchGetItem, request, handler, context);
  }
 
  virtual Model::BatchWriteItemOutcome BatchWriteItem(const Model::BatchWriteItemRequest& request) const;
 
  template <typename BatchWriteItemRequestT = Model::BatchWriteItemRequest>
  Model::BatchWriteItemOutcomeCallable BatchWriteItemCallable(const BatchWriteItemRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::BatchWriteItem, request);
  }
 
  template <typename BatchWriteItemRequestT = Model::BatchWriteItemRequest>
  void BatchWriteItemAsync(const BatchWriteItemRequestT& request, const BatchWriteItemResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::BatchWriteItem, request, handler, context);
  }
 
  virtual Model::CreateBackupOutcome CreateBackup(const Model::CreateBackupRequest& request) const;
 
  template <typename CreateBackupRequestT = Model::CreateBackupRequest>
  Model::CreateBackupOutcomeCallable CreateBackupCallable(const CreateBackupRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::CreateBackup, request);
  }
 
  template <typename CreateBackupRequestT = Model::CreateBackupRequest>
  void CreateBackupAsync(const CreateBackupRequestT& request, const CreateBackupResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::CreateBackup, request, handler, context);
  }
 
  virtual Model::CreateGlobalTableOutcome CreateGlobalTable(const Model::CreateGlobalTableRequest& request) const;
 
  template <typename CreateGlobalTableRequestT = Model::CreateGlobalTableRequest>
  Model::CreateGlobalTableOutcomeCallable CreateGlobalTableCallable(const CreateGlobalTableRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::CreateGlobalTable, request);
  }
 
  template <typename CreateGlobalTableRequestT = Model::CreateGlobalTableRequest>
  void CreateGlobalTableAsync(const CreateGlobalTableRequestT& request, const CreateGlobalTableResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::CreateGlobalTable, request, handler, context);
  }
 
  virtual Model::CreateTableOutcome CreateTable(const Model::CreateTableRequest& request) const;
 
  template <typename CreateTableRequestT = Model::CreateTableRequest>
  Model::CreateTableOutcomeCallable CreateTableCallable(const CreateTableRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::CreateTable, request);
  }
 
  template <typename CreateTableRequestT = Model::CreateTableRequest>
  void CreateTableAsync(const CreateTableRequestT& request, const CreateTableResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::CreateTable, request, handler, context);
  }
 
  virtual Model::DeleteBackupOutcome DeleteBackup(const Model::DeleteBackupRequest& request) const;
 
  template <typename DeleteBackupRequestT = Model::DeleteBackupRequest>
  Model::DeleteBackupOutcomeCallable DeleteBackupCallable(const DeleteBackupRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::DeleteBackup, request);
  }
 
  template <typename DeleteBackupRequestT = Model::DeleteBackupRequest>
  void DeleteBackupAsync(const DeleteBackupRequestT& request, const DeleteBackupResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::DeleteBackup, request, handler, context);
  }
 
  virtual Model::DeleteItemOutcome DeleteItem(const Model::DeleteItemRequest& request) const;
 
  template <typename DeleteItemRequestT = Model::DeleteItemRequest>
  Model::DeleteItemOutcomeCallable DeleteItemCallable(const DeleteItemRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::DeleteItem, request);
  }
 
  template <typename DeleteItemRequestT = Model::DeleteItemRequest>
  void DeleteItemAsync(const DeleteItemRequestT& request, const DeleteItemResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::DeleteItem, request, handler, context);
  }
 
  virtual Model::DeleteResourcePolicyOutcome DeleteResourcePolicy(const Model::DeleteResourcePolicyRequest& request) const;
 
  template <typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
  Model::DeleteResourcePolicyOutcomeCallable DeleteResourcePolicyCallable(const DeleteResourcePolicyRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::DeleteResourcePolicy, request);
  }
 
  template <typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
  void DeleteResourcePolicyAsync(const DeleteResourcePolicyRequestT& request, const DeleteResourcePolicyResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::DeleteResourcePolicy, request, handler, context);
  }
 
  virtual Model::DeleteTableOutcome DeleteTable(const Model::DeleteTableRequest& request) const;
 
  template <typename DeleteTableRequestT = Model::DeleteTableRequest>
  Model::DeleteTableOutcomeCallable DeleteTableCallable(const DeleteTableRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::DeleteTable, request);
  }
 
  template <typename DeleteTableRequestT = Model::DeleteTableRequest>
  void DeleteTableAsync(const DeleteTableRequestT& request, const DeleteTableResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::DeleteTable, request, handler, context);
  }
 
  virtual Model::DescribeBackupOutcome DescribeBackup(const Model::DescribeBackupRequest& request) const;
 
  template <typename DescribeBackupRequestT = Model::DescribeBackupRequest>
  Model::DescribeBackupOutcomeCallable DescribeBackupCallable(const DescribeBackupRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::DescribeBackup, request);
  }
 
  template <typename DescribeBackupRequestT = Model::DescribeBackupRequest>
  void DescribeBackupAsync(const DescribeBackupRequestT& request, const DescribeBackupResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::DescribeBackup, request, handler, context);
  }
 
  virtual Model::DescribeContinuousBackupsOutcome DescribeContinuousBackups(const Model::DescribeContinuousBackupsRequest& request) const;
 
  template <typename DescribeContinuousBackupsRequestT = Model::DescribeContinuousBackupsRequest>
  Model::DescribeContinuousBackupsOutcomeCallable DescribeContinuousBackupsCallable(
      const DescribeContinuousBackupsRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::DescribeContinuousBackups, request);
  }
 
  template <typename DescribeContinuousBackupsRequestT = Model::DescribeContinuousBackupsRequest>
  void DescribeContinuousBackupsAsync(const DescribeContinuousBackupsRequestT& request,
                                      const DescribeContinuousBackupsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::DescribeContinuousBackups, request, handler, context);
  }
 
  virtual Model::DescribeContributorInsightsOutcome DescribeContributorInsights(
      const Model::DescribeContributorInsightsRequest& request) const;
 
  template <typename DescribeContributorInsightsRequestT = Model::DescribeContributorInsightsRequest>
  Model::DescribeContributorInsightsOutcomeCallable DescribeContributorInsightsCallable(
      const DescribeContributorInsightsRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::DescribeContributorInsights, request);
  }
 
  template <typename DescribeContributorInsightsRequestT = Model::DescribeContributorInsightsRequest>
  void DescribeContributorInsightsAsync(const DescribeContributorInsightsRequestT& request,
                                        const DescribeContributorInsightsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::DescribeContributorInsights, request, handler, context);
  }
 
  virtual Model::DescribeEndpointsOutcome DescribeEndpoints(const Model::DescribeEndpointsRequest& request = {}) const;
 
  template <typename DescribeEndpointsRequestT = Model::DescribeEndpointsRequest>
  Model::DescribeEndpointsOutcomeCallable DescribeEndpointsCallable(const DescribeEndpointsRequestT& request = {}) const {
    return SubmitCallable(&DynamoDBClient::DescribeEndpoints, request);
  }
 
  template <typename DescribeEndpointsRequestT = Model::DescribeEndpointsRequest>
  void DescribeEndpointsAsync(const DescribeEndpointsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const DescribeEndpointsRequestT& request = {}) const {
    return SubmitAsync(&DynamoDBClient::DescribeEndpoints, request, handler, context);
  }
 
  virtual Model::DescribeExportOutcome DescribeExport(const Model::DescribeExportRequest& request) const;
 
  template <typename DescribeExportRequestT = Model::DescribeExportRequest>
  Model::DescribeExportOutcomeCallable DescribeExportCallable(const DescribeExportRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::DescribeExport, request);
  }
 
  template <typename DescribeExportRequestT = Model::DescribeExportRequest>
  void DescribeExportAsync(const DescribeExportRequestT& request, const DescribeExportResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::DescribeExport, request, handler, context);
  }
 
  virtual Model::DescribeGlobalTableOutcome DescribeGlobalTable(const Model::DescribeGlobalTableRequest& request) const;
 
  template <typename DescribeGlobalTableRequestT = Model::DescribeGlobalTableRequest>
  Model::DescribeGlobalTableOutcomeCallable DescribeGlobalTableCallable(const DescribeGlobalTableRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::DescribeGlobalTable, request);
  }
 
  template <typename DescribeGlobalTableRequestT = Model::DescribeGlobalTableRequest>
  void DescribeGlobalTableAsync(const DescribeGlobalTableRequestT& request, const DescribeGlobalTableResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::DescribeGlobalTable, request, handler, context);
  }
 
  virtual Model::DescribeGlobalTableSettingsOutcome DescribeGlobalTableSettings(
      const Model::DescribeGlobalTableSettingsRequest& request) const;
 
  template <typename DescribeGlobalTableSettingsRequestT = Model::DescribeGlobalTableSettingsRequest>
  Model::DescribeGlobalTableSettingsOutcomeCallable DescribeGlobalTableSettingsCallable(
      const DescribeGlobalTableSettingsRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::DescribeGlobalTableSettings, request);
  }
 
  template <typename DescribeGlobalTableSettingsRequestT = Model::DescribeGlobalTableSettingsRequest>
  void DescribeGlobalTableSettingsAsync(const DescribeGlobalTableSettingsRequestT& request,
                                        const DescribeGlobalTableSettingsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::DescribeGlobalTableSettings, request, handler, context);
  }
 
  virtual Model::DescribeImportOutcome DescribeImport(const Model::DescribeImportRequest& request) const;
 
  template <typename DescribeImportRequestT = Model::DescribeImportRequest>
  Model::DescribeImportOutcomeCallable DescribeImportCallable(const DescribeImportRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::DescribeImport, request);
  }
 
  template <typename DescribeImportRequestT = Model::DescribeImportRequest>
  void DescribeImportAsync(const DescribeImportRequestT& request, const DescribeImportResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::DescribeImport, request, handler, context);
  }
 
  virtual Model::DescribeKinesisStreamingDestinationOutcome DescribeKinesisStreamingDestination(
      const Model::DescribeKinesisStreamingDestinationRequest& request) const;
 
  template <typename DescribeKinesisStreamingDestinationRequestT = Model::DescribeKinesisStreamingDestinationRequest>
  Model::DescribeKinesisStreamingDestinationOutcomeCallable DescribeKinesisStreamingDestinationCallable(
      const DescribeKinesisStreamingDestinationRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::DescribeKinesisStreamingDestination, request);
  }
 
  template <typename DescribeKinesisStreamingDestinationRequestT = Model::DescribeKinesisStreamingDestinationRequest>
  void DescribeKinesisStreamingDestinationAsync(const DescribeKinesisStreamingDestinationRequestT& request,
                                                const DescribeKinesisStreamingDestinationResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::DescribeKinesisStreamingDestination, request, handler, context);
  }
 
  virtual Model::DescribeLimitsOutcome DescribeLimits(const Model::DescribeLimitsRequest& request = {}) const;
 
  template <typename DescribeLimitsRequestT = Model::DescribeLimitsRequest>
  Model::DescribeLimitsOutcomeCallable DescribeLimitsCallable(const DescribeLimitsRequestT& request = {}) const {
    return SubmitCallable(&DynamoDBClient::DescribeLimits, request);
  }
 
  template <typename DescribeLimitsRequestT = Model::DescribeLimitsRequest>
  void DescribeLimitsAsync(const DescribeLimitsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const DescribeLimitsRequestT& request = {}) const {
    return SubmitAsync(&DynamoDBClient::DescribeLimits, request, handler, context);
  }
 
  virtual Model::DescribeTableOutcome DescribeTable(const Model::DescribeTableRequest& request) const;
 
  template <typename DescribeTableRequestT = Model::DescribeTableRequest>
  Model::DescribeTableOutcomeCallable DescribeTableCallable(const DescribeTableRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::DescribeTable, request);
  }
 
  template <typename DescribeTableRequestT = Model::DescribeTableRequest>
  void DescribeTableAsync(const DescribeTableRequestT& request, const DescribeTableResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::DescribeTable, request, handler, context);
  }
 
  virtual Model::DescribeTableReplicaAutoScalingOutcome DescribeTableReplicaAutoScaling(
      const Model::DescribeTableReplicaAutoScalingRequest& request) const;
 
  template <typename DescribeTableReplicaAutoScalingRequestT = Model::DescribeTableReplicaAutoScalingRequest>
  Model::DescribeTableReplicaAutoScalingOutcomeCallable DescribeTableReplicaAutoScalingCallable(
      const DescribeTableReplicaAutoScalingRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::DescribeTableReplicaAutoScaling, request);
  }
 
  template <typename DescribeTableReplicaAutoScalingRequestT = Model::DescribeTableReplicaAutoScalingRequest>
  void DescribeTableReplicaAutoScalingAsync(const DescribeTableReplicaAutoScalingRequestT& request,
                                            const DescribeTableReplicaAutoScalingResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::DescribeTableReplicaAutoScaling, request, handler, context);
  }
 
  virtual Model::DescribeTimeToLiveOutcome DescribeTimeToLive(const Model::DescribeTimeToLiveRequest& request) const;
 
  template <typename DescribeTimeToLiveRequestT = Model::DescribeTimeToLiveRequest>
  Model::DescribeTimeToLiveOutcomeCallable DescribeTimeToLiveCallable(const DescribeTimeToLiveRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::DescribeTimeToLive, request);
  }
 
  template <typename DescribeTimeToLiveRequestT = Model::DescribeTimeToLiveRequest>
  void DescribeTimeToLiveAsync(const DescribeTimeToLiveRequestT& request, const DescribeTimeToLiveResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::DescribeTimeToLive, request, handler, context);
  }
 
  virtual Model::DisableKinesisStreamingDestinationOutcome DisableKinesisStreamingDestination(
      const Model::DisableKinesisStreamingDestinationRequest& request) const;
 
  template <typename DisableKinesisStreamingDestinationRequestT = Model::DisableKinesisStreamingDestinationRequest>
  Model::DisableKinesisStreamingDestinationOutcomeCallable DisableKinesisStreamingDestinationCallable(
      const DisableKinesisStreamingDestinationRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::DisableKinesisStreamingDestination, request);
  }
 
  template <typename DisableKinesisStreamingDestinationRequestT = Model::DisableKinesisStreamingDestinationRequest>
  void DisableKinesisStreamingDestinationAsync(const DisableKinesisStreamingDestinationRequestT& request,
                                               const DisableKinesisStreamingDestinationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::DisableKinesisStreamingDestination, request, handler, context);
  }
 
  virtual Model::EnableKinesisStreamingDestinationOutcome EnableKinesisStreamingDestination(
      const Model::EnableKinesisStreamingDestinationRequest& request) const;
 
  template <typename EnableKinesisStreamingDestinationRequestT = Model::EnableKinesisStreamingDestinationRequest>
  Model::EnableKinesisStreamingDestinationOutcomeCallable EnableKinesisStreamingDestinationCallable(
      const EnableKinesisStreamingDestinationRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::EnableKinesisStreamingDestination, request);
  }
 
  template <typename EnableKinesisStreamingDestinationRequestT = Model::EnableKinesisStreamingDestinationRequest>
  void EnableKinesisStreamingDestinationAsync(const EnableKinesisStreamingDestinationRequestT& request,
                                              const EnableKinesisStreamingDestinationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::EnableKinesisStreamingDestination, request, handler, context);
  }
 
  virtual Model::ExecuteStatementOutcome ExecuteStatement(const Model::ExecuteStatementRequest& request) const;
 
  template <typename ExecuteStatementRequestT = Model::ExecuteStatementRequest>
  Model::ExecuteStatementOutcomeCallable ExecuteStatementCallable(const ExecuteStatementRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::ExecuteStatement, request);
  }
 
  template <typename ExecuteStatementRequestT = Model::ExecuteStatementRequest>
  void ExecuteStatementAsync(const ExecuteStatementRequestT& request, const ExecuteStatementResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::ExecuteStatement, request, handler, context);
  }
 
  virtual Model::ExecuteTransactionOutcome ExecuteTransaction(const Model::ExecuteTransactionRequest& request) const;
 
  template <typename ExecuteTransactionRequestT = Model::ExecuteTransactionRequest>
  Model::ExecuteTransactionOutcomeCallable ExecuteTransactionCallable(const ExecuteTransactionRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::ExecuteTransaction, request);
  }
 
  template <typename ExecuteTransactionRequestT = Model::ExecuteTransactionRequest>
  void ExecuteTransactionAsync(const ExecuteTransactionRequestT& request, const ExecuteTransactionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::ExecuteTransaction, request, handler, context);
  }
 
  virtual Model::ExportTableToPointInTimeOutcome ExportTableToPointInTime(const Model::ExportTableToPointInTimeRequest& request) const;
 
  template <typename ExportTableToPointInTimeRequestT = Model::ExportTableToPointInTimeRequest>
  Model::ExportTableToPointInTimeOutcomeCallable ExportTableToPointInTimeCallable(const ExportTableToPointInTimeRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::ExportTableToPointInTime, request);
  }
 
  template <typename ExportTableToPointInTimeRequestT = Model::ExportTableToPointInTimeRequest>
  void ExportTableToPointInTimeAsync(const ExportTableToPointInTimeRequestT& request,
                                     const ExportTableToPointInTimeResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::ExportTableToPointInTime, request, handler, context);
  }
 
  virtual Model::GetItemOutcome GetItem(const Model::GetItemRequest& request) const;
 
  template <typename GetItemRequestT = Model::GetItemRequest>
  Model::GetItemOutcomeCallable GetItemCallable(const GetItemRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::GetItem, request);
  }
 
  template <typename GetItemRequestT = Model::GetItemRequest>
  void GetItemAsync(const GetItemRequestT& request, const GetItemResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::GetItem, request, handler, context);
  }
 
  virtual Model::GetResourcePolicyOutcome GetResourcePolicy(const Model::GetResourcePolicyRequest& request) const;
 
  template <typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
  Model::GetResourcePolicyOutcomeCallable GetResourcePolicyCallable(const GetResourcePolicyRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::GetResourcePolicy, request);
  }
 
  template <typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
  void GetResourcePolicyAsync(const GetResourcePolicyRequestT& request, const GetResourcePolicyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::GetResourcePolicy, request, handler, context);
  }
 
  virtual Model::ImportTableOutcome ImportTable(const Model::ImportTableRequest& request) const;
 
  template <typename ImportTableRequestT = Model::ImportTableRequest>
  Model::ImportTableOutcomeCallable ImportTableCallable(const ImportTableRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::ImportTable, request);
  }
 
  template <typename ImportTableRequestT = Model::ImportTableRequest>
  void ImportTableAsync(const ImportTableRequestT& request, const ImportTableResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::ImportTable, request, handler, context);
  }
 
  virtual Model::ListBackupsOutcome ListBackups(const Model::ListBackupsRequest& request = {}) const;
 
  template <typename ListBackupsRequestT = Model::ListBackupsRequest>
  Model::ListBackupsOutcomeCallable ListBackupsCallable(const ListBackupsRequestT& request = {}) const {
    return SubmitCallable(&DynamoDBClient::ListBackups, request);
  }
 
  template <typename ListBackupsRequestT = Model::ListBackupsRequest>
  void ListBackupsAsync(const ListBackupsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListBackupsRequestT& request = {}) const {
    return SubmitAsync(&DynamoDBClient::ListBackups, request, handler, context);
  }
 
  virtual Model::ListContributorInsightsOutcome ListContributorInsights(const Model::ListContributorInsightsRequest& request = {}) const;
 
  template <typename ListContributorInsightsRequestT = Model::ListContributorInsightsRequest>
  Model::ListContributorInsightsOutcomeCallable ListContributorInsightsCallable(const ListContributorInsightsRequestT& request = {}) const {
    return SubmitCallable(&DynamoDBClient::ListContributorInsights, request);
  }
 
  template <typename ListContributorInsightsRequestT = Model::ListContributorInsightsRequest>
  void ListContributorInsightsAsync(const ListContributorInsightsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListContributorInsightsRequestT& request = {}) const {
    return SubmitAsync(&DynamoDBClient::ListContributorInsights, request, handler, context);
  }
 
  virtual Model::ListExportsOutcome ListExports(const Model::ListExportsRequest& request = {}) const;
 
  template <typename ListExportsRequestT = Model::ListExportsRequest>
  Model::ListExportsOutcomeCallable ListExportsCallable(const ListExportsRequestT& request = {}) const {
    return SubmitCallable(&DynamoDBClient::ListExports, request);
  }
 
  template <typename ListExportsRequestT = Model::ListExportsRequest>
  void ListExportsAsync(const ListExportsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListExportsRequestT& request = {}) const {
    return SubmitAsync(&DynamoDBClient::ListExports, request, handler, context);
  }
 
  virtual Model::ListGlobalTablesOutcome ListGlobalTables(const Model::ListGlobalTablesRequest& request = {}) const;
 
  template <typename ListGlobalTablesRequestT = Model::ListGlobalTablesRequest>
  Model::ListGlobalTablesOutcomeCallable ListGlobalTablesCallable(const ListGlobalTablesRequestT& request = {}) const {
    return SubmitCallable(&DynamoDBClient::ListGlobalTables, request);
  }
 
  template <typename ListGlobalTablesRequestT = Model::ListGlobalTablesRequest>
  void ListGlobalTablesAsync(const ListGlobalTablesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListGlobalTablesRequestT& request = {}) const {
    return SubmitAsync(&DynamoDBClient::ListGlobalTables, request, handler, context);
  }
 
  virtual Model::ListImportsOutcome ListImports(const Model::ListImportsRequest& request = {}) const;
 
  template <typename ListImportsRequestT = Model::ListImportsRequest>
  Model::ListImportsOutcomeCallable ListImportsCallable(const ListImportsRequestT& request = {}) const {
    return SubmitCallable(&DynamoDBClient::ListImports, request);
  }
 
  template <typename ListImportsRequestT = Model::ListImportsRequest>
  void ListImportsAsync(const ListImportsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListImportsRequestT& request = {}) const {
    return SubmitAsync(&DynamoDBClient::ListImports, request, handler, context);
  }
 
  virtual Model::ListTablesOutcome ListTables(const Model::ListTablesRequest& request = {}) const;
 
  template <typename ListTablesRequestT = Model::ListTablesRequest>
  Model::ListTablesOutcomeCallable ListTablesCallable(const ListTablesRequestT& request = {}) const {
    return SubmitCallable(&DynamoDBClient::ListTables, request);
  }
 
  template <typename ListTablesRequestT = Model::ListTablesRequest>
  void ListTablesAsync(const ListTablesResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                       const ListTablesRequestT& request = {}) const {
    return SubmitAsync(&DynamoDBClient::ListTables, request, handler, context);
  }
 
  virtual Model::ListTagsOfResourceOutcome ListTagsOfResource(const Model::ListTagsOfResourceRequest& request) const;
 
  template <typename ListTagsOfResourceRequestT = Model::ListTagsOfResourceRequest>
  Model::ListTagsOfResourceOutcomeCallable ListTagsOfResourceCallable(const ListTagsOfResourceRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::ListTagsOfResource, request);
  }
 
  template <typename ListTagsOfResourceRequestT = Model::ListTagsOfResourceRequest>
  void ListTagsOfResourceAsync(const ListTagsOfResourceRequestT& request, const ListTagsOfResourceResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::ListTagsOfResource, request, handler, context);
  }
 
  virtual Model::PutItemOutcome PutItem(const Model::PutItemRequest& request) const;
 
  template <typename PutItemRequestT = Model::PutItemRequest>
  Model::PutItemOutcomeCallable PutItemCallable(const PutItemRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::PutItem, request);
  }
 
  template <typename PutItemRequestT = Model::PutItemRequest>
  void PutItemAsync(const PutItemRequestT& request, const PutItemResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::PutItem, request, handler, context);
  }
 
  virtual Model::PutResourcePolicyOutcome PutResourcePolicy(const Model::PutResourcePolicyRequest& request) const;
 
  template <typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
  Model::PutResourcePolicyOutcomeCallable PutResourcePolicyCallable(const PutResourcePolicyRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::PutResourcePolicy, request);
  }
 
  template <typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
  void PutResourcePolicyAsync(const PutResourcePolicyRequestT& request, const PutResourcePolicyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::PutResourcePolicy, request, handler, context);
  }
 
  virtual Model::QueryOutcome Query(const Model::QueryRequest& request) const;
 
  template <typename QueryRequestT = Model::QueryRequest>
  Model::QueryOutcomeCallable QueryCallable(const QueryRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::Query, request);
  }
 
  template <typename QueryRequestT = Model::QueryRequest>
  void QueryAsync(const QueryRequestT& request, const QueryResponseReceivedHandler& handler,
                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::Query, request, handler, context);
  }
 
  virtual Model::RestoreTableFromBackupOutcome RestoreTableFromBackup(const Model::RestoreTableFromBackupRequest& request) const;
 
  template <typename RestoreTableFromBackupRequestT = Model::RestoreTableFromBackupRequest>
  Model::RestoreTableFromBackupOutcomeCallable RestoreTableFromBackupCallable(const RestoreTableFromBackupRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::RestoreTableFromBackup, request);
  }
 
  template <typename RestoreTableFromBackupRequestT = Model::RestoreTableFromBackupRequest>
  void RestoreTableFromBackupAsync(const RestoreTableFromBackupRequestT& request,
                                   const RestoreTableFromBackupResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::RestoreTableFromBackup, request, handler, context);
  }
 
  virtual Model::RestoreTableToPointInTimeOutcome RestoreTableToPointInTime(const Model::RestoreTableToPointInTimeRequest& request) const;
 
  template <typename RestoreTableToPointInTimeRequestT = Model::RestoreTableToPointInTimeRequest>
  Model::RestoreTableToPointInTimeOutcomeCallable RestoreTableToPointInTimeCallable(
      const RestoreTableToPointInTimeRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::RestoreTableToPointInTime, request);
  }
 
  template <typename RestoreTableToPointInTimeRequestT = Model::RestoreTableToPointInTimeRequest>
  void RestoreTableToPointInTimeAsync(const RestoreTableToPointInTimeRequestT& request,
                                      const RestoreTableToPointInTimeResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::RestoreTableToPointInTime, request, handler, context);
  }
 
  virtual Model::ScanOutcome Scan(const Model::ScanRequest& request) const;
 
  template <typename ScanRequestT = Model::ScanRequest>
  Model::ScanOutcomeCallable ScanCallable(const ScanRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::Scan, request);
  }
 
  template <typename ScanRequestT = Model::ScanRequest>
  void ScanAsync(const ScanRequestT& request, const ScanResponseReceivedHandler& handler,
                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::Scan, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::TagResource, request, handler, context);
  }
 
  virtual Model::TransactGetItemsOutcome TransactGetItems(const Model::TransactGetItemsRequest& request) const;
 
  template <typename TransactGetItemsRequestT = Model::TransactGetItemsRequest>
  Model::TransactGetItemsOutcomeCallable TransactGetItemsCallable(const TransactGetItemsRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::TransactGetItems, request);
  }
 
  template <typename TransactGetItemsRequestT = Model::TransactGetItemsRequest>
  void TransactGetItemsAsync(const TransactGetItemsRequestT& request, const TransactGetItemsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::TransactGetItems, request, handler, context);
  }
 
  virtual Model::TransactWriteItemsOutcome TransactWriteItems(const Model::TransactWriteItemsRequest& request) const;
 
  template <typename TransactWriteItemsRequestT = Model::TransactWriteItemsRequest>
  Model::TransactWriteItemsOutcomeCallable TransactWriteItemsCallable(const TransactWriteItemsRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::TransactWriteItems, request);
  }
 
  template <typename TransactWriteItemsRequestT = Model::TransactWriteItemsRequest>
  void TransactWriteItemsAsync(const TransactWriteItemsRequestT& request, const TransactWriteItemsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::TransactWriteItems, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateContinuousBackupsOutcome UpdateContinuousBackups(const Model::UpdateContinuousBackupsRequest& request) const;
 
  template <typename UpdateContinuousBackupsRequestT = Model::UpdateContinuousBackupsRequest>
  Model::UpdateContinuousBackupsOutcomeCallable UpdateContinuousBackupsCallable(const UpdateContinuousBackupsRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::UpdateContinuousBackups, request);
  }
 
  template <typename UpdateContinuousBackupsRequestT = Model::UpdateContinuousBackupsRequest>
  void UpdateContinuousBackupsAsync(const UpdateContinuousBackupsRequestT& request,
                                    const UpdateContinuousBackupsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::UpdateContinuousBackups, request, handler, context);
  }
 
  virtual Model::UpdateContributorInsightsOutcome UpdateContributorInsights(const Model::UpdateContributorInsightsRequest& request) const;
 
  template <typename UpdateContributorInsightsRequestT = Model::UpdateContributorInsightsRequest>
  Model::UpdateContributorInsightsOutcomeCallable UpdateContributorInsightsCallable(
      const UpdateContributorInsightsRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::UpdateContributorInsights, request);
  }
 
  template <typename UpdateContributorInsightsRequestT = Model::UpdateContributorInsightsRequest>
  void UpdateContributorInsightsAsync(const UpdateContributorInsightsRequestT& request,
                                      const UpdateContributorInsightsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::UpdateContributorInsights, request, handler, context);
  }
 
  virtual Model::UpdateGlobalTableOutcome UpdateGlobalTable(const Model::UpdateGlobalTableRequest& request) const;
 
  template <typename UpdateGlobalTableRequestT = Model::UpdateGlobalTableRequest>
  Model::UpdateGlobalTableOutcomeCallable UpdateGlobalTableCallable(const UpdateGlobalTableRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::UpdateGlobalTable, request);
  }
 
  template <typename UpdateGlobalTableRequestT = Model::UpdateGlobalTableRequest>
  void UpdateGlobalTableAsync(const UpdateGlobalTableRequestT& request, const UpdateGlobalTableResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::UpdateGlobalTable, request, handler, context);
  }
 
  virtual Model::UpdateGlobalTableSettingsOutcome UpdateGlobalTableSettings(const Model::UpdateGlobalTableSettingsRequest& request) const;
 
  template <typename UpdateGlobalTableSettingsRequestT = Model::UpdateGlobalTableSettingsRequest>
  Model::UpdateGlobalTableSettingsOutcomeCallable UpdateGlobalTableSettingsCallable(
      const UpdateGlobalTableSettingsRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::UpdateGlobalTableSettings, request);
  }
 
  template <typename UpdateGlobalTableSettingsRequestT = Model::UpdateGlobalTableSettingsRequest>
  void UpdateGlobalTableSettingsAsync(const UpdateGlobalTableSettingsRequestT& request,
                                      const UpdateGlobalTableSettingsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::UpdateGlobalTableSettings, request, handler, context);
  }
 
  virtual Model::UpdateItemOutcome UpdateItem(const Model::UpdateItemRequest& request) const;
 
  template <typename UpdateItemRequestT = Model::UpdateItemRequest>
  Model::UpdateItemOutcomeCallable UpdateItemCallable(const UpdateItemRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::UpdateItem, request);
  }
 
  template <typename UpdateItemRequestT = Model::UpdateItemRequest>
  void UpdateItemAsync(const UpdateItemRequestT& request, const UpdateItemResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::UpdateItem, request, handler, context);
  }
 
  virtual Model::UpdateKinesisStreamingDestinationOutcome UpdateKinesisStreamingDestination(
      const Model::UpdateKinesisStreamingDestinationRequest& request) const;
 
  template <typename UpdateKinesisStreamingDestinationRequestT = Model::UpdateKinesisStreamingDestinationRequest>
  Model::UpdateKinesisStreamingDestinationOutcomeCallable UpdateKinesisStreamingDestinationCallable(
      const UpdateKinesisStreamingDestinationRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::UpdateKinesisStreamingDestination, request);
  }
 
  template <typename UpdateKinesisStreamingDestinationRequestT = Model::UpdateKinesisStreamingDestinationRequest>
  void UpdateKinesisStreamingDestinationAsync(const UpdateKinesisStreamingDestinationRequestT& request,
                                              const UpdateKinesisStreamingDestinationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::UpdateKinesisStreamingDestination, request, handler, context);
  }
 
  virtual Model::UpdateTableOutcome UpdateTable(const Model::UpdateTableRequest& request) const;
 
  template <typename UpdateTableRequestT = Model::UpdateTableRequest>
  Model::UpdateTableOutcomeCallable UpdateTableCallable(const UpdateTableRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::UpdateTable, request);
  }
 
  template <typename UpdateTableRequestT = Model::UpdateTableRequest>
  void UpdateTableAsync(const UpdateTableRequestT& request, const UpdateTableResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::UpdateTable, request, handler, context);
  }
 
  virtual Model::UpdateTableReplicaAutoScalingOutcome UpdateTableReplicaAutoScaling(
      const Model::UpdateTableReplicaAutoScalingRequest& request) const;
 
  template <typename UpdateTableReplicaAutoScalingRequestT = Model::UpdateTableReplicaAutoScalingRequest>
  Model::UpdateTableReplicaAutoScalingOutcomeCallable UpdateTableReplicaAutoScalingCallable(
      const UpdateTableReplicaAutoScalingRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::UpdateTableReplicaAutoScaling, request);
  }
 
  template <typename UpdateTableReplicaAutoScalingRequestT = Model::UpdateTableReplicaAutoScalingRequest>
  void UpdateTableReplicaAutoScalingAsync(const UpdateTableReplicaAutoScalingRequestT& request,
                                          const UpdateTableReplicaAutoScalingResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::UpdateTableReplicaAutoScaling, request, handler, context);
  }
 
  virtual Model::UpdateTimeToLiveOutcome UpdateTimeToLive(const Model::UpdateTimeToLiveRequest& request) const;
 
  template <typename UpdateTimeToLiveRequestT = Model::UpdateTimeToLiveRequest>
  Model::UpdateTimeToLiveOutcomeCallable UpdateTimeToLiveCallable(const UpdateTimeToLiveRequestT& request) const {
    return SubmitCallable(&DynamoDBClient::UpdateTimeToLive, request);
  }
 
  template <typename UpdateTimeToLiveRequestT = Model::UpdateTimeToLiveRequest>
  void UpdateTimeToLiveAsync(const UpdateTimeToLiveRequestT& request, const UpdateTimeToLiveResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DynamoDBClient::UpdateTimeToLive, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<DynamoDBEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<DynamoDBClient>;
 
  void OptionallyUpdateDescribeEndpointsCache(Aws::Endpoint::AWSEndpoint& resolvedEndpoint, const Aws::String& operationName,
                                              const Aws::String& endpointKey,
                                              const Aws::DynamoDB::Model::DescribeEndpointsRequest& endpointRequest,
                                              bool enforceDiscovery) const;
  mutable Aws::Utils::ConcurrentCache<Aws::String, Aws::String> m_endpointsCache;
};
 
}  // namespace DynamoDB
}  // namespace Aws