DynamoDBClient.h

 
#pragma once
#include <aws/dynamodb/DynamoDB_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/dynamodb/DynamoDBServiceClientModel.h>
#include <smithy/client/AwsSmithyClient.h>
#include <smithy/identity/auth/built-in/SigV4AuthSchemeResolver.h>
#include <smithy/identity/auth/built-in/SigV4AuthScheme.h>
#include <smithy/client/serializer/JsonOutcomeSerializer.h>
#include <aws/dynamodb/DynamoDBErrorMarshaller.h>
 
namespace Aws
{
namespace DynamoDB
{
  AWS_DYNAMODB_API extern const char SERVICE_NAME[];
  class AWS_DYNAMODB_API DynamoDBClient : Aws::Client::ClientWithAsyncTemplateMethods<DynamoDBClient>,
    smithy::client::AwsSmithyClientT<Aws::DynamoDB::SERVICE_NAME,
      Aws::DynamoDB::DynamoDBClientConfiguration,
      smithy::SigV4AuthSchemeResolver<>,
      Aws::Crt::Variant<smithy::SigV4AuthScheme>,
      DynamoDBEndpointProviderBase,
      smithy::client::JsonOutcomeSerializer,
      smithy::client::JsonOutcome,
      Aws::Client::DynamoDBErrorMarshaller>
  {
    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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      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