✨feat(hos_client_create, hos_client_destory): 多次调用destory不会导致重复释放

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/CMakeLists.txt

@@ -0,0 +1,76 @@
+add_project(aws-cpp-sdk-dynamodb "C++ SDK for the AWS dynamodb service" aws-cpp-sdk-core)
+
+file(GLOB AWS_DYNAMODB_HEADERS
+    "include/aws/dynamodb/*.h"
+)
+
+file(GLOB AWS_DYNAMODB_MODEL_HEADERS
+    "include/aws/dynamodb/model/*.h"
+)
+
+file(GLOB AWS_DYNAMODB_SOURCE
+    "source/*.cpp"
+)
+
+file(GLOB AWS_DYNAMODB_MODEL_SOURCE
+    "source/model/*.cpp"
+)
+
+file(GLOB DYNAMODB_UNIFIED_HEADERS
+    ${AWS_DYNAMODB_HEADERS}
+    ${AWS_DYNAMODB_MODEL_HEADERS}
+)
+
+file(GLOB DYNAMODB_UNITY_SRC
+    ${AWS_DYNAMODB_SOURCE}
+    ${AWS_DYNAMODB_MODEL_SOURCE}
+)
+
+if(ENABLE_UNITY_BUILD)
+    enable_unity_build("DYNAMODB" DYNAMODB_UNITY_SRC)
+endif()
+
+file(GLOB DYNAMODB_SRC
+    ${DYNAMODB_UNIFIED_HEADERS}
+    ${DYNAMODB_UNITY_SRC}
+)
+
+if(WIN32)
+    #if we are compiling for visual studio, create a sane directory tree.
+    if(MSVC)
+        source_group("Header Files\\aws\\dynamodb" FILES ${AWS_DYNAMODB_HEADERS})
+        source_group("Header Files\\aws\\dynamodb\\model" FILES ${AWS_DYNAMODB_MODEL_HEADERS})
+        source_group("Source Files" FILES ${AWS_DYNAMODB_SOURCE})
+        source_group("Source Files\\model" FILES ${AWS_DYNAMODB_MODEL_SOURCE})
+    endif(MSVC)
+endif()
+
+set(DYNAMODB_INCLUDES
+    "${CMAKE_CURRENT_SOURCE_DIR}/include/"
+)
+
+add_library(${PROJECT_NAME} ${DYNAMODB_SRC})
+add_library(AWS::${PROJECT_NAME} ALIAS ${PROJECT_NAME})
+
+set_compiler_flags(${PROJECT_NAME})
+set_compiler_warnings(${PROJECT_NAME})
+
+if(USE_WINDOWS_DLL_SEMANTICS AND BUILD_SHARED_LIBS)
+    target_compile_definitions(${PROJECT_NAME} PRIVATE "AWS_DYNAMODB_EXPORTS")
+endif()
+
+target_include_directories(${PROJECT_NAME} PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:include>)
+
+target_link_libraries(${PROJECT_NAME} PRIVATE ${PLATFORM_DEP_LIBS} ${PROJECT_LIBS})
+
+
+setup_install()
+
+install (FILES ${AWS_DYNAMODB_HEADERS} DESTINATION ${INCLUDE_DIRECTORY}/aws/dynamodb)
+install (FILES ${AWS_DYNAMODB_MODEL_HEADERS} DESTINATION ${INCLUDE_DIRECTORY}/aws/dynamodb/model)
+
+do_packaging()
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/DynamoDBEndpoint.h

@@ -0,0 +1,21 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/Region.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+
+namespace DynamoDB
+{
+namespace DynamoDBEndpoint
+{
+AWS_DYNAMODB_API Aws::String ForRegion(const Aws::String& regionName, bool useDualStack = false);
+} // namespace DynamoDBEndpoint
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/DynamoDBErrorMarshaller.h

@@ -0,0 +1,23 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/client/AWSErrorMarshaller.h>
+
+namespace Aws
+{
+namespace Client
+{
+
+class AWS_DYNAMODB_API DynamoDBErrorMarshaller : public Aws::Client::JsonErrorMarshaller
+{
+public:
+  Aws::Client::AWSError<Aws::Client::CoreErrors> FindErrorByName(const char* exceptionName) const override;
+};
+
+} // namespace Client
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/DynamoDBErrors.h

@@ -0,0 +1,94 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+
+#include <aws/core/client/AWSError.h>
+#include <aws/core/client/CoreErrors.h>
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+enum class DynamoDBErrors
+{
+  //From Core//
+  //////////////////////////////////////////////////////////////////////////////////////////
+  INCOMPLETE_SIGNATURE = 0,
+  INTERNAL_FAILURE = 1,
+  INVALID_ACTION = 2,
+  INVALID_CLIENT_TOKEN_ID = 3,
+  INVALID_PARAMETER_COMBINATION = 4,
+  INVALID_QUERY_PARAMETER = 5,
+  INVALID_PARAMETER_VALUE = 6,
+  MISSING_ACTION = 7, // SDK should never allow
+  MISSING_AUTHENTICATION_TOKEN = 8, // SDK should never allow
+  MISSING_PARAMETER = 9, // SDK should never allow
+  OPT_IN_REQUIRED = 10,
+  REQUEST_EXPIRED = 11,
+  SERVICE_UNAVAILABLE = 12,
+  THROTTLING = 13,
+  VALIDATION = 14,
+  ACCESS_DENIED = 15,
+  RESOURCE_NOT_FOUND = 16,
+  UNRECOGNIZED_CLIENT = 17,
+  MALFORMED_QUERY_STRING = 18,
+  SLOW_DOWN = 19,
+  REQUEST_TIME_TOO_SKEWED = 20,
+  INVALID_SIGNATURE = 21,
+  SIGNATURE_DOES_NOT_MATCH = 22,
+  INVALID_ACCESS_KEY_ID = 23,
+  REQUEST_TIMEOUT = 24,
+  NETWORK_CONNECTION = 99,
+
+  UNKNOWN = 100,
+  ///////////////////////////////////////////////////////////////////////////////////////////
+
+  BACKUP_IN_USE= static_cast<int>(Aws::Client::CoreErrors::SERVICE_EXTENSION_START_RANGE) + 1,
+  BACKUP_NOT_FOUND,
+  CONDITIONAL_CHECK_FAILED,
+  CONTINUOUS_BACKUPS_UNAVAILABLE,
+  GLOBAL_TABLE_ALREADY_EXISTS,
+  GLOBAL_TABLE_NOT_FOUND,
+  IDEMPOTENT_PARAMETER_MISMATCH,
+  INDEX_NOT_FOUND,
+  INVALID_RESTORE_TIME,
+  ITEM_COLLECTION_SIZE_LIMIT_EXCEEDED,
+  LIMIT_EXCEEDED,
+  POINT_IN_TIME_RECOVERY_UNAVAILABLE,
+  PROVISIONED_THROUGHPUT_EXCEEDED,
+  REPLICA_ALREADY_EXISTS,
+  REPLICA_NOT_FOUND,
+  REQUEST_LIMIT_EXCEEDED,
+  RESOURCE_IN_USE,
+  TABLE_ALREADY_EXISTS,
+  TABLE_IN_USE,
+  TABLE_NOT_FOUND,
+  TRANSACTION_CANCELED,
+  TRANSACTION_CONFLICT,
+  TRANSACTION_IN_PROGRESS
+};
+
+class AWS_DYNAMODB_API DynamoDBError : public Aws::Client::AWSError<DynamoDBErrors>
+{
+public:
+  DynamoDBError() {}
+  DynamoDBError(const Aws::Client::AWSError<Aws::Client::CoreErrors>& rhs) : Aws::Client::AWSError<DynamoDBErrors>(rhs) {}
+  DynamoDBError(Aws::Client::AWSError<Aws::Client::CoreErrors>&& rhs) : Aws::Client::AWSError<DynamoDBErrors>(rhs) {}
+  DynamoDBError(const Aws::Client::AWSError<DynamoDBErrors>& rhs) : Aws::Client::AWSError<DynamoDBErrors>(rhs) {}
+  DynamoDBError(Aws::Client::AWSError<DynamoDBErrors>&& rhs) : Aws::Client::AWSError<DynamoDBErrors>(rhs) {}
+
+  template <typename T>
+  T GetModeledError();
+};
+
+namespace DynamoDBErrorMapper
+{
+  AWS_DYNAMODB_API Aws::Client::AWSError<Aws::Client::CoreErrors> GetErrorForName(const char* errorName);
+}
+
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/DynamoDBRequest.h

@@ -0,0 +1,42 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/AmazonSerializableWebServiceRequest.h>
+#include <aws/core/utils/UnreferencedParam.h>
+#include <aws/core/http/HttpRequest.h>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+  class AWS_DYNAMODB_API DynamoDBRequest : public Aws::AmazonSerializableWebServiceRequest
+  {
+  public:
+    virtual ~DynamoDBRequest () {}
+
+    void AddParametersToRequest(Aws::Http::HttpRequest& httpRequest) const { AWS_UNREFERENCED_PARAM(httpRequest); }
+
+    inline Aws::Http::HeaderValueCollection GetHeaders() const override
+    {
+      auto headers = GetRequestSpecificHeaders();
+
+      if(headers.size() == 0 || (headers.size() > 0 && headers.count(Aws::Http::CONTENT_TYPE_HEADER) == 0))
+      {
+        headers.emplace(Aws::Http::HeaderValuePair(Aws::Http::CONTENT_TYPE_HEADER, Aws::AMZN_JSON_CONTENT_TYPE_1_0 ));
+      }
+      headers.emplace(Aws::Http::HeaderValuePair(Aws::Http::API_VERSION_HEADER, "2012-08-10"));
+      return headers;
+    }
+
+  protected:
+    virtual Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const { return Aws::Http::HeaderValueCollection(); }
+
+  };
+
+
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/DynamoDB_EXPORTS.h

@@ -0,0 +1,29 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+
+#ifdef _MSC_VER
+    //disable windows complaining about max template size.
+    #pragma warning (disable : 4503)
+#endif // _MSC_VER
+
+#if defined (USE_WINDOWS_DLL_SEMANTICS) || defined (_WIN32)
+    #ifdef _MSC_VER
+        #pragma warning(disable : 4251)
+    #endif // _MSC_VER
+
+    #ifdef USE_IMPORT_EXPORT
+        #ifdef AWS_DYNAMODB_EXPORTS
+            #define AWS_DYNAMODB_API __declspec(dllexport)
+        #else
+            #define AWS_DYNAMODB_API __declspec(dllimport)
+        #endif /* AWS_DYNAMODB_EXPORTS */
+    #else
+        #define AWS_DYNAMODB_API
+    #endif // USE_IMPORT_EXPORT
+#else // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)
+    #define AWS_DYNAMODB_API
+#endif // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/ArchivalSummary.h

@@ -0,0 +1,221 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/DateTime.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Contains details of a table archival operation.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ArchivalSummary">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API ArchivalSummary
+  {
+  public:
+    ArchivalSummary();
+    ArchivalSummary(Aws::Utils::Json::JsonView jsonValue);
+    ArchivalSummary& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The date and time when table archival was initiated by DynamoDB, in UNIX
+     * epoch time format.</p>
+     */
+    inline const Aws::Utils::DateTime& GetArchivalDateTime() const{ return m_archivalDateTime; }
+
+    /**
+     * <p>The date and time when table archival was initiated by DynamoDB, in UNIX
+     * epoch time format.</p>
+     */
+    inline bool ArchivalDateTimeHasBeenSet() const { return m_archivalDateTimeHasBeenSet; }
+
+    /**
+     * <p>The date and time when table archival was initiated by DynamoDB, in UNIX
+     * epoch time format.</p>
+     */
+    inline void SetArchivalDateTime(const Aws::Utils::DateTime& value) { m_archivalDateTimeHasBeenSet = true; m_archivalDateTime = value; }
+
+    /**
+     * <p>The date and time when table archival was initiated by DynamoDB, in UNIX
+     * epoch time format.</p>
+     */
+    inline void SetArchivalDateTime(Aws::Utils::DateTime&& value) { m_archivalDateTimeHasBeenSet = true; m_archivalDateTime = std::move(value); }
+
+    /**
+     * <p>The date and time when table archival was initiated by DynamoDB, in UNIX
+     * epoch time format.</p>
+     */
+    inline ArchivalSummary& WithArchivalDateTime(const Aws::Utils::DateTime& value) { SetArchivalDateTime(value); return *this;}
+
+    /**
+     * <p>The date and time when table archival was initiated by DynamoDB, in UNIX
+     * epoch time format.</p>
+     */
+    inline ArchivalSummary& WithArchivalDateTime(Aws::Utils::DateTime&& value) { SetArchivalDateTime(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The reason DynamoDB archived the table. Currently, the only possible value
+     * is:</p> <ul> <li> <p> <code>INACCESSIBLE_ENCRYPTION_CREDENTIALS</code> - The
+     * table was archived due to the table's AWS KMS key being inaccessible for more
+     * than seven days. An On-Demand backup was created at the archival time.</p> </li>
+     * </ul>
+     */
+    inline const Aws::String& GetArchivalReason() const{ return m_archivalReason; }
+
+    /**
+     * <p>The reason DynamoDB archived the table. Currently, the only possible value
+     * is:</p> <ul> <li> <p> <code>INACCESSIBLE_ENCRYPTION_CREDENTIALS</code> - The
+     * table was archived due to the table's AWS KMS key being inaccessible for more
+     * than seven days. An On-Demand backup was created at the archival time.</p> </li>
+     * </ul>
+     */
+    inline bool ArchivalReasonHasBeenSet() const { return m_archivalReasonHasBeenSet; }
+
+    /**
+     * <p>The reason DynamoDB archived the table. Currently, the only possible value
+     * is:</p> <ul> <li> <p> <code>INACCESSIBLE_ENCRYPTION_CREDENTIALS</code> - The
+     * table was archived due to the table's AWS KMS key being inaccessible for more
+     * than seven days. An On-Demand backup was created at the archival time.</p> </li>
+     * </ul>
+     */
+    inline void SetArchivalReason(const Aws::String& value) { m_archivalReasonHasBeenSet = true; m_archivalReason = value; }
+
+    /**
+     * <p>The reason DynamoDB archived the table. Currently, the only possible value
+     * is:</p> <ul> <li> <p> <code>INACCESSIBLE_ENCRYPTION_CREDENTIALS</code> - The
+     * table was archived due to the table's AWS KMS key being inaccessible for more
+     * than seven days. An On-Demand backup was created at the archival time.</p> </li>
+     * </ul>
+     */
+    inline void SetArchivalReason(Aws::String&& value) { m_archivalReasonHasBeenSet = true; m_archivalReason = std::move(value); }
+
+    /**
+     * <p>The reason DynamoDB archived the table. Currently, the only possible value
+     * is:</p> <ul> <li> <p> <code>INACCESSIBLE_ENCRYPTION_CREDENTIALS</code> - The
+     * table was archived due to the table's AWS KMS key being inaccessible for more
+     * than seven days. An On-Demand backup was created at the archival time.</p> </li>
+     * </ul>
+     */
+    inline void SetArchivalReason(const char* value) { m_archivalReasonHasBeenSet = true; m_archivalReason.assign(value); }
+
+    /**
+     * <p>The reason DynamoDB archived the table. Currently, the only possible value
+     * is:</p> <ul> <li> <p> <code>INACCESSIBLE_ENCRYPTION_CREDENTIALS</code> - The
+     * table was archived due to the table's AWS KMS key being inaccessible for more
+     * than seven days. An On-Demand backup was created at the archival time.</p> </li>
+     * </ul>
+     */
+    inline ArchivalSummary& WithArchivalReason(const Aws::String& value) { SetArchivalReason(value); return *this;}
+
+    /**
+     * <p>The reason DynamoDB archived the table. Currently, the only possible value
+     * is:</p> <ul> <li> <p> <code>INACCESSIBLE_ENCRYPTION_CREDENTIALS</code> - The
+     * table was archived due to the table's AWS KMS key being inaccessible for more
+     * than seven days. An On-Demand backup was created at the archival time.</p> </li>
+     * </ul>
+     */
+    inline ArchivalSummary& WithArchivalReason(Aws::String&& value) { SetArchivalReason(std::move(value)); return *this;}
+
+    /**
+     * <p>The reason DynamoDB archived the table. Currently, the only possible value
+     * is:</p> <ul> <li> <p> <code>INACCESSIBLE_ENCRYPTION_CREDENTIALS</code> - The
+     * table was archived due to the table's AWS KMS key being inaccessible for more
+     * than seven days. An On-Demand backup was created at the archival time.</p> </li>
+     * </ul>
+     */
+    inline ArchivalSummary& WithArchivalReason(const char* value) { SetArchivalReason(value); return *this;}
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the backup the table was archived to, when
+     * applicable in the archival reason. If you wish to restore this backup to the
+     * same table name, you will need to delete the original table.</p>
+     */
+    inline const Aws::String& GetArchivalBackupArn() const{ return m_archivalBackupArn; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the backup the table was archived to, when
+     * applicable in the archival reason. If you wish to restore this backup to the
+     * same table name, you will need to delete the original table.</p>
+     */
+    inline bool ArchivalBackupArnHasBeenSet() const { return m_archivalBackupArnHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the backup the table was archived to, when
+     * applicable in the archival reason. If you wish to restore this backup to the
+     * same table name, you will need to delete the original table.</p>
+     */
+    inline void SetArchivalBackupArn(const Aws::String& value) { m_archivalBackupArnHasBeenSet = true; m_archivalBackupArn = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the backup the table was archived to, when
+     * applicable in the archival reason. If you wish to restore this backup to the
+     * same table name, you will need to delete the original table.</p>
+     */
+    inline void SetArchivalBackupArn(Aws::String&& value) { m_archivalBackupArnHasBeenSet = true; m_archivalBackupArn = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the backup the table was archived to, when
+     * applicable in the archival reason. If you wish to restore this backup to the
+     * same table name, you will need to delete the original table.</p>
+     */
+    inline void SetArchivalBackupArn(const char* value) { m_archivalBackupArnHasBeenSet = true; m_archivalBackupArn.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the backup the table was archived to, when
+     * applicable in the archival reason. If you wish to restore this backup to the
+     * same table name, you will need to delete the original table.</p>
+     */
+    inline ArchivalSummary& WithArchivalBackupArn(const Aws::String& value) { SetArchivalBackupArn(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the backup the table was archived to, when
+     * applicable in the archival reason. If you wish to restore this backup to the
+     * same table name, you will need to delete the original table.</p>
+     */
+    inline ArchivalSummary& WithArchivalBackupArn(Aws::String&& value) { SetArchivalBackupArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the backup the table was archived to, when
+     * applicable in the archival reason. If you wish to restore this backup to the
+     * same table name, you will need to delete the original table.</p>
+     */
+    inline ArchivalSummary& WithArchivalBackupArn(const char* value) { SetArchivalBackupArn(value); return *this;}
+
+  private:
+
+    Aws::Utils::DateTime m_archivalDateTime;
+    bool m_archivalDateTimeHasBeenSet;
+
+    Aws::String m_archivalReason;
+    bool m_archivalReasonHasBeenSet;
+
+    Aws::String m_archivalBackupArn;
+    bool m_archivalBackupArnHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/AttributeAction.h

@@ -0,0 +1,32 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+  enum class AttributeAction
+  {
+    NOT_SET,
+    ADD,
+    PUT,
+    DELETE_
+  };
+
+namespace AttributeActionMapper
+{
+AWS_DYNAMODB_API AttributeAction GetAttributeActionForName(const Aws::String& name);
+
+AWS_DYNAMODB_API Aws::String GetNameForAttributeAction(AttributeAction value);
+} // namespace AttributeActionMapper
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/AttributeDefinition.h

@@ -0,0 +1,142 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/dynamodb/model/ScalarAttributeType.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents an attribute for describing the key schema for the table and
+   * indexes.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/AttributeDefinition">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API AttributeDefinition
+  {
+  public:
+    AttributeDefinition();
+    AttributeDefinition(Aws::Utils::Json::JsonView jsonValue);
+    AttributeDefinition& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>A name for the attribute.</p>
+     */
+    inline const Aws::String& GetAttributeName() const{ return m_attributeName; }
+
+    /**
+     * <p>A name for the attribute.</p>
+     */
+    inline bool AttributeNameHasBeenSet() const { return m_attributeNameHasBeenSet; }
+
+    /**
+     * <p>A name for the attribute.</p>
+     */
+    inline void SetAttributeName(const Aws::String& value) { m_attributeNameHasBeenSet = true; m_attributeName = value; }
+
+    /**
+     * <p>A name for the attribute.</p>
+     */
+    inline void SetAttributeName(Aws::String&& value) { m_attributeNameHasBeenSet = true; m_attributeName = std::move(value); }
+
+    /**
+     * <p>A name for the attribute.</p>
+     */
+    inline void SetAttributeName(const char* value) { m_attributeNameHasBeenSet = true; m_attributeName.assign(value); }
+
+    /**
+     * <p>A name for the attribute.</p>
+     */
+    inline AttributeDefinition& WithAttributeName(const Aws::String& value) { SetAttributeName(value); return *this;}
+
+    /**
+     * <p>A name for the attribute.</p>
+     */
+    inline AttributeDefinition& WithAttributeName(Aws::String&& value) { SetAttributeName(std::move(value)); return *this;}
+
+    /**
+     * <p>A name for the attribute.</p>
+     */
+    inline AttributeDefinition& WithAttributeName(const char* value) { SetAttributeName(value); return *this;}
+
+
+    /**
+     * <p>The data type for the attribute, where:</p> <ul> <li> <p> <code>S</code> -
+     * the attribute is of type String</p> </li> <li> <p> <code>N</code> - the
+     * attribute is of type Number</p> </li> <li> <p> <code>B</code> - the attribute is
+     * of type Binary</p> </li> </ul>
+     */
+    inline const ScalarAttributeType& GetAttributeType() const{ return m_attributeType; }
+
+    /**
+     * <p>The data type for the attribute, where:</p> <ul> <li> <p> <code>S</code> -
+     * the attribute is of type String</p> </li> <li> <p> <code>N</code> - the
+     * attribute is of type Number</p> </li> <li> <p> <code>B</code> - the attribute is
+     * of type Binary</p> </li> </ul>
+     */
+    inline bool AttributeTypeHasBeenSet() const { return m_attributeTypeHasBeenSet; }
+
+    /**
+     * <p>The data type for the attribute, where:</p> <ul> <li> <p> <code>S</code> -
+     * the attribute is of type String</p> </li> <li> <p> <code>N</code> - the
+     * attribute is of type Number</p> </li> <li> <p> <code>B</code> - the attribute is
+     * of type Binary</p> </li> </ul>
+     */
+    inline void SetAttributeType(const ScalarAttributeType& value) { m_attributeTypeHasBeenSet = true; m_attributeType = value; }
+
+    /**
+     * <p>The data type for the attribute, where:</p> <ul> <li> <p> <code>S</code> -
+     * the attribute is of type String</p> </li> <li> <p> <code>N</code> - the
+     * attribute is of type Number</p> </li> <li> <p> <code>B</code> - the attribute is
+     * of type Binary</p> </li> </ul>
+     */
+    inline void SetAttributeType(ScalarAttributeType&& value) { m_attributeTypeHasBeenSet = true; m_attributeType = std::move(value); }
+
+    /**
+     * <p>The data type for the attribute, where:</p> <ul> <li> <p> <code>S</code> -
+     * the attribute is of type String</p> </li> <li> <p> <code>N</code> - the
+     * attribute is of type Number</p> </li> <li> <p> <code>B</code> - the attribute is
+     * of type Binary</p> </li> </ul>
+     */
+    inline AttributeDefinition& WithAttributeType(const ScalarAttributeType& value) { SetAttributeType(value); return *this;}
+
+    /**
+     * <p>The data type for the attribute, where:</p> <ul> <li> <p> <code>S</code> -
+     * the attribute is of type String</p> </li> <li> <p> <code>N</code> - the
+     * attribute is of type Number</p> </li> <li> <p> <code>B</code> - the attribute is
+     * of type Binary</p> </li> </ul>
+     */
+    inline AttributeDefinition& WithAttributeType(ScalarAttributeType&& value) { SetAttributeType(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_attributeName;
+    bool m_attributeNameHasBeenSet;
+
+    ScalarAttributeType m_attributeType;
+    bool m_attributeTypeHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/AttributeValue.h

@@ -0,0 +1,173 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/Array.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+class AttributeValueValue;
+
+enum class ValueType {STRING, NUMBER, BYTEBUFFER, STRING_SET, NUMBER_SET, BYTEBUFFER_SET, ATTRIBUTE_MAP, ATTRIBUTE_LIST, BOOL, NULLVALUE};
+
+/// http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_AttributeValue.html
+class AWS_DYNAMODB_API AttributeValue
+{
+public:
+    AttributeValue() {};
+    explicit AttributeValue(const Aws::String& s) { SetS(s); }
+    explicit AttributeValue(const Aws::Vector<Aws::String>& ss) { SetSS(ss); }
+    AttributeValue(Aws::Utils::Json::JsonView jsonValue) { *this = jsonValue; }
+
+    /// returns the String value if the value is specialized to this type, otherwise an empty String
+    const Aws::String GetS() const;
+    /// if already specialized to a String, sets the value to this String
+    /// if uninitialized, specializes the type to a String with specified value
+    /// if already specialized to another type then the behavior is undefined
+    AttributeValue& SetS(const Aws::String& s);
+    /// if uninitialized, specializes the type to a String with specified value
+    /// if already specialized to another type then the behavior is undefined
+    AttributeValue& SetS(const char* n) { return SetS(Aws::String(n)); }
+
+    /// returns the Number value if the value is specialized to this type, otherwise an empty String
+    const Aws::String GetN() const;
+    /// if already specialized to a Number, sets the value to this Number
+    /// if uninitialized, specializes the type to a Number with specified value
+    /// if already specialized to another type then the behavior is undefined
+    AttributeValue& SetN(const Aws::String& n);
+    /// if already specialized to a Number, sets the value to this Number
+    /// if uninitialized, specializes the type to a Number with specified value
+    /// if already specialized to another type then the behavior is undefined
+    AttributeValue& SetN(const char* n) { return SetN(Aws::String(n)); }
+    /// if already specialized to a Number, sets the value to this Number
+    /// if uninitialized, specializes the type to a Number with specified value
+    /// if already specialized to another type then the behavior is undefined
+    AttributeValue& SetN(const int nItem) { return SetN(Aws::String(std::to_string(nItem).c_str())); }
+    /// if already specialized to a Number, sets the value to this Number
+    /// if uninitialized, specializes the type to a Number with specified value
+    /// if already specialized to another type then the behavior is undefined
+    AttributeValue& SetN(const float nItem) { return SetN(Aws::String(std::to_string(nItem).c_str())); }
+    /// if already specialized to a Number, sets the value to this Number
+    /// if uninitialized, specializes the type to a Number with specified value
+    /// if already specialized to another type then the behavior is undefined
+    AttributeValue& SetN(const double nItem) { return SetN(Aws::String(std::to_string(nItem).c_str())); }
+
+    /// returns the ByteBuffer if the value is specialized to this type, otherwise an empty Buffer
+    const Aws::Utils::ByteBuffer GetB() const;
+    /// if already specialized to a ByteBuffer, sets the value to this value
+    /// if uninitialized, specializes the type to a ByteBuffer with the specified value
+    /// if already specialized to another type then the behavior is undefined
+    AttributeValue& SetB(const Aws::Utils::ByteBuffer& b);
+
+    /// returns the String Vector if the value is specialized to this type, otherwise an empty Vector
+    const Aws::Vector<Aws::String> GetSS() const;
+    /// if already specialized to a String Set, sets to these values
+    /// if uninitialized, specializes the type to a String Set with specified values
+    /// if already specialized to another type then the behavior is undefined
+    AttributeValue& SetSS(const Aws::Vector<Aws::String>& ss);
+    /// if the value is already specialized to a String Set then this value is appended
+    /// if uninitialized, specializes the type to a String Set with this initial value
+    /// if already specialized to another type then the behavior is undefined
+    AttributeValue& AddSItem(const Aws::String& sItem);
+    /// if the value is already specialized to a String Set then this value is appended
+    /// if uninitialized, specializes the type to a String Set with this initial value
+    /// if already specialized to another type then the behavior is undefined
+    AttributeValue& AddSItem(const char* sItem) { return AddSItem(Aws::String(sItem)); }
+
+    /// returns the Number Vector if the value is specialized to this type, otherwise an empty Vector
+    const Aws::Vector<Aws::String> GetNS() const;
+    /// if already specialized to a Number Set, sets to these values
+    /// if uninitialized, specializes the type to a Number Set with specified values
+    /// if already specialized to another type then the behavior is undefined
+    AttributeValue& SetNS(const Aws::Vector<Aws::String>& ns);
+    /// if the value is already specialized to a Number Set then this value is appended
+    /// if uninitialized, specializes the type to a Number Set with this initial value
+    /// if already specialized to another type then the behavior is undefined
+    AttributeValue& AddNItem(const Aws::String& nItem);
+    /// if the value is already specialized to a Number Set then this value is appended
+    /// if uninitialized, specializes the type to a Number Set with this initial value
+    /// if already specialized to another type then the behavior is undefined
+    AttributeValue& AddNItem(const char* nItem) { return AddNItem(Aws::String(nItem)); }
+
+    /// returns the ByteBuffer Vector if the value is specialized to this type, otherwise an empty Vector
+    const Aws::Vector<Aws::Utils::ByteBuffer> GetBS() const;
+    /// if already specialized to a ByteBuffer Set, sets to these values
+    /// if uninitialized, specializes the type to a ByteBuffer Set with specified values
+    /// if already specialized to another type then the behavior is undefined
+    AttributeValue& SetBS(const Aws::Vector<Aws::Utils::ByteBuffer>& bs);
+    /// if the value is already specialized to a ByteBuffer Set then this value is appended
+    /// if uninitialized, specializes the type to a ByteBuffer Set with this initial value
+    /// if already specialized to another type then the behavior is undefined
+    AttributeValue& AddBItem(const Aws::Utils::ByteBuffer& bItem);
+    /// if the value is already specialized to a ByteBuffer Set then this value is appended
+    /// if uninitialized, specializes the type to a ByteBuffer Set with this initial value
+    /// if already specialized to another type then the behavior is undefined
+    AttributeValue& AddBItem(const unsigned char* bItem, size_t size);
+
+    /// returns the Attribute Map if the value is specialized to this type, otherwise an empty Map
+    const Aws::Map<Aws::String, const std::shared_ptr<AttributeValue>> GetM() const;
+    /// if already specialized to an Attribute Map, sets to these values
+    /// if uninitialized, specializes the type to an Attribute Map with specified values
+    /// if already specialized to another type then the behavior is undefined
+    AttributeValue& SetM(const Aws::Map<Aws::String, const std::shared_ptr<AttributeValue>>& map);
+    /// if the value is already specialized to a Map then this value is inserted
+    /// if uninitialized, specializes the type to a Map with these initial values
+    /// if already specialized to another type then the behavior is undefined
+    AttributeValue& AddMEntry(const Aws::String& key, const std::shared_ptr<AttributeValue>& value);
+    /// if the value is already specialized to a Map then this value is inserted
+    /// if uninitialized, specializes the type to a Map with these initial values
+    /// if already specialized to another type then the behavior is undefined
+    AttributeValue& AddMEntry(const char* key, const std::shared_ptr<AttributeValue>& value) { return AddMEntry(Aws::String(key), value); }
+
+    /// returns the Attribute List if the value is specialized to this type, otherwise an empty Vector
+    const Aws::Vector<std::shared_ptr<AttributeValue>> GetL() const;
+    /// if already specialized to an Attribute List, sets to these values
+    /// if uninitialized, specializes the type to an Attribute List with specified values
+    /// if already specialized to another type then the behavior is undefined
+    AttributeValue& SetL(const Aws::Vector<std::shared_ptr<AttributeValue>>& list);
+    /// if the value is already specialized to a List then this value is appended
+    /// if uninitialized, specializes the type to a List with these initial values
+    /// if already specialized to another type then the behavior is undefined
+    AttributeValue& AddLItem(const std::shared_ptr<AttributeValue>& listItem);
+
+    /// returns the boolean if the value is specialized to this type, otherwise false
+    bool GetBool() const;
+    /// if already specialized to a boolean, sets to this value
+    /// if uninitialized, specializes the type to a boolean with the specified value
+    /// if already specialized to another type then the behavior is undefined
+    AttributeValue& SetBool(bool value);
+
+    /// returns Null-Set-Value if the value is specialized to this type, otherwise false
+    bool GetNull() const;
+    /// if already specialized to a Null, sets to this value
+    /// if uninitialized, specializes the type to Null with the specified value
+    /// if already specialized to another type then the behavior is undefined
+    AttributeValue& SetNull(bool value);
+
+    AttributeValue& operator = (Aws::Utils::Json::JsonView);
+
+    bool operator == (const AttributeValue& other) const;
+    inline bool operator != (const AttributeValue& other) const { return !(*this == other); }
+
+    Aws::String SerializeAttribute() const;
+    Aws::Utils::Json::JsonValue Jsonize() const;
+    ValueType GetType() const;
+
+private:
+    std::shared_ptr<AttributeValueValue> m_value;
+};
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/AttributeValueUpdate.h

@@ -0,0 +1,439 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/model/AttributeValue.h>
+#include <aws/dynamodb/model/AttributeAction.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>For the <code>UpdateItem</code> operation, represents the attributes to be
+   * modified, the action to perform on each, and the new value for each.</p> 
+   * <p>You cannot use <code>UpdateItem</code> to update any primary key attributes.
+   * Instead, you will need to delete the item, and then use <code>PutItem</code> to
+   * create a new item with new attributes.</p>  <p>Attribute values cannot be
+   * null; string and binary type attributes must have lengths greater than zero; and
+   * set type attributes must not be empty. Requests with empty values will be
+   * rejected with a <code>ValidationException</code> exception.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/AttributeValueUpdate">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API AttributeValueUpdate
+  {
+  public:
+    AttributeValueUpdate();
+    AttributeValueUpdate(Aws::Utils::Json::JsonView jsonValue);
+    AttributeValueUpdate& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Represents the data for an attribute.</p> <p>Each attribute value is
+     * described as a name-value pair. The name is the data type, and the value is the
+     * data itself.</p> <p>For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes">Data
+     * Types</a> in the <i>Amazon DynamoDB Developer Guide</i>. </p>
+     */
+    inline const AttributeValue& GetValue() const{ return m_value; }
+
+    /**
+     * <p>Represents the data for an attribute.</p> <p>Each attribute value is
+     * described as a name-value pair. The name is the data type, and the value is the
+     * data itself.</p> <p>For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes">Data
+     * Types</a> in the <i>Amazon DynamoDB Developer Guide</i>. </p>
+     */
+    inline bool ValueHasBeenSet() const { return m_valueHasBeenSet; }
+
+    /**
+     * <p>Represents the data for an attribute.</p> <p>Each attribute value is
+     * described as a name-value pair. The name is the data type, and the value is the
+     * data itself.</p> <p>For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes">Data
+     * Types</a> in the <i>Amazon DynamoDB Developer Guide</i>. </p>
+     */
+    inline void SetValue(const AttributeValue& value) { m_valueHasBeenSet = true; m_value = value; }
+
+    /**
+     * <p>Represents the data for an attribute.</p> <p>Each attribute value is
+     * described as a name-value pair. The name is the data type, and the value is the
+     * data itself.</p> <p>For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes">Data
+     * Types</a> in the <i>Amazon DynamoDB Developer Guide</i>. </p>
+     */
+    inline void SetValue(AttributeValue&& value) { m_valueHasBeenSet = true; m_value = std::move(value); }
+
+    /**
+     * <p>Represents the data for an attribute.</p> <p>Each attribute value is
+     * described as a name-value pair. The name is the data type, and the value is the
+     * data itself.</p> <p>For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes">Data
+     * Types</a> in the <i>Amazon DynamoDB Developer Guide</i>. </p>
+     */
+    inline AttributeValueUpdate& WithValue(const AttributeValue& value) { SetValue(value); return *this;}
+
+    /**
+     * <p>Represents the data for an attribute.</p> <p>Each attribute value is
+     * described as a name-value pair. The name is the data type, and the value is the
+     * data itself.</p> <p>For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes">Data
+     * Types</a> in the <i>Amazon DynamoDB Developer Guide</i>. </p>
+     */
+    inline AttributeValueUpdate& WithValue(AttributeValue&& value) { SetValue(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Specifies how to perform the update. Valid values are <code>PUT</code>
+     * (default), <code>DELETE</code>, and <code>ADD</code>. The behavior depends on
+     * whether the specified primary key already exists in the table.</p> <p> <b>If an
+     * item with the specified <i>Key</i> is found in the table:</b> </p> <ul> <li> <p>
+     * <code>PUT</code> - Adds the specified attribute to the item. If the attribute
+     * already exists, it is replaced by the new value. </p> </li> <li> <p>
+     * <code>DELETE</code> - If no value is specified, the attribute and its value are
+     * removed from the item. The data type of the specified value must match the
+     * existing value's data type.</p> <p>If a <i>set</i> of values is specified, then
+     * those values are subtracted from the old set. For example, if the attribute
+     * value was the set <code>[a,b,c]</code> and the <code>DELETE</code> action
+     * specified <code>[a,c]</code>, then the final attribute value would be
+     * <code>[b]</code>. Specifying an empty set is an error.</p> </li> <li> <p>
+     * <code>ADD</code> - If the attribute does not already exist, then the attribute
+     * and its values are added to the item. If the attribute does exist, then the
+     * behavior of <code>ADD</code> depends on the data type of the attribute:</p> <ul>
+     * <li> <p>If the existing attribute is a number, and if <code>Value</code> is also
+     * a number, then the <code>Value</code> is mathematically added to the existing
+     * attribute. If <code>Value</code> is a negative number, then it is subtracted
+     * from the existing attribute.</p>  <p> If you use <code>ADD</code> to
+     * increment or decrement a number value for an item that doesn't exist before the
+     * update, DynamoDB uses 0 as the initial value.</p> <p>In addition, if you use
+     * <code>ADD</code> to update an existing item, and intend to increment or
+     * decrement an attribute value which does not yet exist, DynamoDB uses
+     * <code>0</code> as the initial value. For example, suppose that the item you want
+     * to update does not yet have an attribute named <i>itemcount</i>, but you decide
+     * to <code>ADD</code> the number <code>3</code> to this attribute anyway, even
+     * though it currently does not exist. DynamoDB will create the <i>itemcount</i>
+     * attribute, set its initial value to <code>0</code>, and finally add
+     * <code>3</code> to it. The result will be a new <i>itemcount</i> attribute in the
+     * item, with a value of <code>3</code>.</p>  </li> <li> <p>If the existing
+     * data type is a set, and if the <code>Value</code> is also a set, then the
+     * <code>Value</code> is added to the existing set. (This is a <i>set</i>
+     * operation, not mathematical addition.) For example, if the attribute value was
+     * the set <code>[1,2]</code>, and the <code>ADD</code> action specified
+     * <code>[3]</code>, then the final attribute value would be <code>[1,2,3]</code>.
+     * An error occurs if an Add action is specified for a set attribute and the
+     * attribute type specified does not match the existing set type. </p> <p>Both sets
+     * must have the same primitive data type. For example, if the existing data type
+     * is a set of strings, the <code>Value</code> must also be a set of strings. The
+     * same holds true for number sets and binary sets.</p> </li> </ul> <p>This action
+     * is only valid for an existing attribute whose data type is number or is a set.
+     * Do not use <code>ADD</code> for any other data types.</p> </li> </ul> <p> <b>If
+     * no item with the specified <i>Key</i> is found:</b> </p> <ul> <li> <p>
+     * <code>PUT</code> - DynamoDB creates a new item with the specified primary key,
+     * and then adds the attribute. </p> </li> <li> <p> <code>DELETE</code> - Nothing
+     * happens; there is no attribute to delete.</p> </li> <li> <p> <code>ADD</code> -
+     * DynamoDB creates an item with the supplied primary key and number (or set of
+     * numbers) for the attribute value. The only data types allowed are number and
+     * number set; no other data types can be specified.</p> </li> </ul>
+     */
+    inline const AttributeAction& GetAction() const{ return m_action; }
+
+    /**
+     * <p>Specifies how to perform the update. Valid values are <code>PUT</code>
+     * (default), <code>DELETE</code>, and <code>ADD</code>. The behavior depends on
+     * whether the specified primary key already exists in the table.</p> <p> <b>If an
+     * item with the specified <i>Key</i> is found in the table:</b> </p> <ul> <li> <p>
+     * <code>PUT</code> - Adds the specified attribute to the item. If the attribute
+     * already exists, it is replaced by the new value. </p> </li> <li> <p>
+     * <code>DELETE</code> - If no value is specified, the attribute and its value are
+     * removed from the item. The data type of the specified value must match the
+     * existing value's data type.</p> <p>If a <i>set</i> of values is specified, then
+     * those values are subtracted from the old set. For example, if the attribute
+     * value was the set <code>[a,b,c]</code> and the <code>DELETE</code> action
+     * specified <code>[a,c]</code>, then the final attribute value would be
+     * <code>[b]</code>. Specifying an empty set is an error.</p> </li> <li> <p>
+     * <code>ADD</code> - If the attribute does not already exist, then the attribute
+     * and its values are added to the item. If the attribute does exist, then the
+     * behavior of <code>ADD</code> depends on the data type of the attribute:</p> <ul>
+     * <li> <p>If the existing attribute is a number, and if <code>Value</code> is also
+     * a number, then the <code>Value</code> is mathematically added to the existing
+     * attribute. If <code>Value</code> is a negative number, then it is subtracted
+     * from the existing attribute.</p>  <p> If you use <code>ADD</code> to
+     * increment or decrement a number value for an item that doesn't exist before the
+     * update, DynamoDB uses 0 as the initial value.</p> <p>In addition, if you use
+     * <code>ADD</code> to update an existing item, and intend to increment or
+     * decrement an attribute value which does not yet exist, DynamoDB uses
+     * <code>0</code> as the initial value. For example, suppose that the item you want
+     * to update does not yet have an attribute named <i>itemcount</i>, but you decide
+     * to <code>ADD</code> the number <code>3</code> to this attribute anyway, even
+     * though it currently does not exist. DynamoDB will create the <i>itemcount</i>
+     * attribute, set its initial value to <code>0</code>, and finally add
+     * <code>3</code> to it. The result will be a new <i>itemcount</i> attribute in the
+     * item, with a value of <code>3</code>.</p>  </li> <li> <p>If the existing
+     * data type is a set, and if the <code>Value</code> is also a set, then the
+     * <code>Value</code> is added to the existing set. (This is a <i>set</i>
+     * operation, not mathematical addition.) For example, if the attribute value was
+     * the set <code>[1,2]</code>, and the <code>ADD</code> action specified
+     * <code>[3]</code>, then the final attribute value would be <code>[1,2,3]</code>.
+     * An error occurs if an Add action is specified for a set attribute and the
+     * attribute type specified does not match the existing set type. </p> <p>Both sets
+     * must have the same primitive data type. For example, if the existing data type
+     * is a set of strings, the <code>Value</code> must also be a set of strings. The
+     * same holds true for number sets and binary sets.</p> </li> </ul> <p>This action
+     * is only valid for an existing attribute whose data type is number or is a set.
+     * Do not use <code>ADD</code> for any other data types.</p> </li> </ul> <p> <b>If
+     * no item with the specified <i>Key</i> is found:</b> </p> <ul> <li> <p>
+     * <code>PUT</code> - DynamoDB creates a new item with the specified primary key,
+     * and then adds the attribute. </p> </li> <li> <p> <code>DELETE</code> - Nothing
+     * happens; there is no attribute to delete.</p> </li> <li> <p> <code>ADD</code> -
+     * DynamoDB creates an item with the supplied primary key and number (or set of
+     * numbers) for the attribute value. The only data types allowed are number and
+     * number set; no other data types can be specified.</p> </li> </ul>
+     */
+    inline bool ActionHasBeenSet() const { return m_actionHasBeenSet; }
+
+    /**
+     * <p>Specifies how to perform the update. Valid values are <code>PUT</code>
+     * (default), <code>DELETE</code>, and <code>ADD</code>. The behavior depends on
+     * whether the specified primary key already exists in the table.</p> <p> <b>If an
+     * item with the specified <i>Key</i> is found in the table:</b> </p> <ul> <li> <p>
+     * <code>PUT</code> - Adds the specified attribute to the item. If the attribute
+     * already exists, it is replaced by the new value. </p> </li> <li> <p>
+     * <code>DELETE</code> - If no value is specified, the attribute and its value are
+     * removed from the item. The data type of the specified value must match the
+     * existing value's data type.</p> <p>If a <i>set</i> of values is specified, then
+     * those values are subtracted from the old set. For example, if the attribute
+     * value was the set <code>[a,b,c]</code> and the <code>DELETE</code> action
+     * specified <code>[a,c]</code>, then the final attribute value would be
+     * <code>[b]</code>. Specifying an empty set is an error.</p> </li> <li> <p>
+     * <code>ADD</code> - If the attribute does not already exist, then the attribute
+     * and its values are added to the item. If the attribute does exist, then the
+     * behavior of <code>ADD</code> depends on the data type of the attribute:</p> <ul>
+     * <li> <p>If the existing attribute is a number, and if <code>Value</code> is also
+     * a number, then the <code>Value</code> is mathematically added to the existing
+     * attribute. If <code>Value</code> is a negative number, then it is subtracted
+     * from the existing attribute.</p>  <p> If you use <code>ADD</code> to
+     * increment or decrement a number value for an item that doesn't exist before the
+     * update, DynamoDB uses 0 as the initial value.</p> <p>In addition, if you use
+     * <code>ADD</code> to update an existing item, and intend to increment or
+     * decrement an attribute value which does not yet exist, DynamoDB uses
+     * <code>0</code> as the initial value. For example, suppose that the item you want
+     * to update does not yet have an attribute named <i>itemcount</i>, but you decide
+     * to <code>ADD</code> the number <code>3</code> to this attribute anyway, even
+     * though it currently does not exist. DynamoDB will create the <i>itemcount</i>
+     * attribute, set its initial value to <code>0</code>, and finally add
+     * <code>3</code> to it. The result will be a new <i>itemcount</i> attribute in the
+     * item, with a value of <code>3</code>.</p>  </li> <li> <p>If the existing
+     * data type is a set, and if the <code>Value</code> is also a set, then the
+     * <code>Value</code> is added to the existing set. (This is a <i>set</i>
+     * operation, not mathematical addition.) For example, if the attribute value was
+     * the set <code>[1,2]</code>, and the <code>ADD</code> action specified
+     * <code>[3]</code>, then the final attribute value would be <code>[1,2,3]</code>.
+     * An error occurs if an Add action is specified for a set attribute and the
+     * attribute type specified does not match the existing set type. </p> <p>Both sets
+     * must have the same primitive data type. For example, if the existing data type
+     * is a set of strings, the <code>Value</code> must also be a set of strings. The
+     * same holds true for number sets and binary sets.</p> </li> </ul> <p>This action
+     * is only valid for an existing attribute whose data type is number or is a set.
+     * Do not use <code>ADD</code> for any other data types.</p> </li> </ul> <p> <b>If
+     * no item with the specified <i>Key</i> is found:</b> </p> <ul> <li> <p>
+     * <code>PUT</code> - DynamoDB creates a new item with the specified primary key,
+     * and then adds the attribute. </p> </li> <li> <p> <code>DELETE</code> - Nothing
+     * happens; there is no attribute to delete.</p> </li> <li> <p> <code>ADD</code> -
+     * DynamoDB creates an item with the supplied primary key and number (or set of
+     * numbers) for the attribute value. The only data types allowed are number and
+     * number set; no other data types can be specified.</p> </li> </ul>
+     */
+    inline void SetAction(const AttributeAction& value) { m_actionHasBeenSet = true; m_action = value; }
+
+    /**
+     * <p>Specifies how to perform the update. Valid values are <code>PUT</code>
+     * (default), <code>DELETE</code>, and <code>ADD</code>. The behavior depends on
+     * whether the specified primary key already exists in the table.</p> <p> <b>If an
+     * item with the specified <i>Key</i> is found in the table:</b> </p> <ul> <li> <p>
+     * <code>PUT</code> - Adds the specified attribute to the item. If the attribute
+     * already exists, it is replaced by the new value. </p> </li> <li> <p>
+     * <code>DELETE</code> - If no value is specified, the attribute and its value are
+     * removed from the item. The data type of the specified value must match the
+     * existing value's data type.</p> <p>If a <i>set</i> of values is specified, then
+     * those values are subtracted from the old set. For example, if the attribute
+     * value was the set <code>[a,b,c]</code> and the <code>DELETE</code> action
+     * specified <code>[a,c]</code>, then the final attribute value would be
+     * <code>[b]</code>. Specifying an empty set is an error.</p> </li> <li> <p>
+     * <code>ADD</code> - If the attribute does not already exist, then the attribute
+     * and its values are added to the item. If the attribute does exist, then the
+     * behavior of <code>ADD</code> depends on the data type of the attribute:</p> <ul>
+     * <li> <p>If the existing attribute is a number, and if <code>Value</code> is also
+     * a number, then the <code>Value</code> is mathematically added to the existing
+     * attribute. If <code>Value</code> is a negative number, then it is subtracted
+     * from the existing attribute.</p>  <p> If you use <code>ADD</code> to
+     * increment or decrement a number value for an item that doesn't exist before the
+     * update, DynamoDB uses 0 as the initial value.</p> <p>In addition, if you use
+     * <code>ADD</code> to update an existing item, and intend to increment or
+     * decrement an attribute value which does not yet exist, DynamoDB uses
+     * <code>0</code> as the initial value. For example, suppose that the item you want
+     * to update does not yet have an attribute named <i>itemcount</i>, but you decide
+     * to <code>ADD</code> the number <code>3</code> to this attribute anyway, even
+     * though it currently does not exist. DynamoDB will create the <i>itemcount</i>
+     * attribute, set its initial value to <code>0</code>, and finally add
+     * <code>3</code> to it. The result will be a new <i>itemcount</i> attribute in the
+     * item, with a value of <code>3</code>.</p>  </li> <li> <p>If the existing
+     * data type is a set, and if the <code>Value</code> is also a set, then the
+     * <code>Value</code> is added to the existing set. (This is a <i>set</i>
+     * operation, not mathematical addition.) For example, if the attribute value was
+     * the set <code>[1,2]</code>, and the <code>ADD</code> action specified
+     * <code>[3]</code>, then the final attribute value would be <code>[1,2,3]</code>.
+     * An error occurs if an Add action is specified for a set attribute and the
+     * attribute type specified does not match the existing set type. </p> <p>Both sets
+     * must have the same primitive data type. For example, if the existing data type
+     * is a set of strings, the <code>Value</code> must also be a set of strings. The
+     * same holds true for number sets and binary sets.</p> </li> </ul> <p>This action
+     * is only valid for an existing attribute whose data type is number or is a set.
+     * Do not use <code>ADD</code> for any other data types.</p> </li> </ul> <p> <b>If
+     * no item with the specified <i>Key</i> is found:</b> </p> <ul> <li> <p>
+     * <code>PUT</code> - DynamoDB creates a new item with the specified primary key,
+     * and then adds the attribute. </p> </li> <li> <p> <code>DELETE</code> - Nothing
+     * happens; there is no attribute to delete.</p> </li> <li> <p> <code>ADD</code> -
+     * DynamoDB creates an item with the supplied primary key and number (or set of
+     * numbers) for the attribute value. The only data types allowed are number and
+     * number set; no other data types can be specified.</p> </li> </ul>
+     */
+    inline void SetAction(AttributeAction&& value) { m_actionHasBeenSet = true; m_action = std::move(value); }
+
+    /**
+     * <p>Specifies how to perform the update. Valid values are <code>PUT</code>
+     * (default), <code>DELETE</code>, and <code>ADD</code>. The behavior depends on
+     * whether the specified primary key already exists in the table.</p> <p> <b>If an
+     * item with the specified <i>Key</i> is found in the table:</b> </p> <ul> <li> <p>
+     * <code>PUT</code> - Adds the specified attribute to the item. If the attribute
+     * already exists, it is replaced by the new value. </p> </li> <li> <p>
+     * <code>DELETE</code> - If no value is specified, the attribute and its value are
+     * removed from the item. The data type of the specified value must match the
+     * existing value's data type.</p> <p>If a <i>set</i> of values is specified, then
+     * those values are subtracted from the old set. For example, if the attribute
+     * value was the set <code>[a,b,c]</code> and the <code>DELETE</code> action
+     * specified <code>[a,c]</code>, then the final attribute value would be
+     * <code>[b]</code>. Specifying an empty set is an error.</p> </li> <li> <p>
+     * <code>ADD</code> - If the attribute does not already exist, then the attribute
+     * and its values are added to the item. If the attribute does exist, then the
+     * behavior of <code>ADD</code> depends on the data type of the attribute:</p> <ul>
+     * <li> <p>If the existing attribute is a number, and if <code>Value</code> is also
+     * a number, then the <code>Value</code> is mathematically added to the existing
+     * attribute. If <code>Value</code> is a negative number, then it is subtracted
+     * from the existing attribute.</p>  <p> If you use <code>ADD</code> to
+     * increment or decrement a number value for an item that doesn't exist before the
+     * update, DynamoDB uses 0 as the initial value.</p> <p>In addition, if you use
+     * <code>ADD</code> to update an existing item, and intend to increment or
+     * decrement an attribute value which does not yet exist, DynamoDB uses
+     * <code>0</code> as the initial value. For example, suppose that the item you want
+     * to update does not yet have an attribute named <i>itemcount</i>, but you decide
+     * to <code>ADD</code> the number <code>3</code> to this attribute anyway, even
+     * though it currently does not exist. DynamoDB will create the <i>itemcount</i>
+     * attribute, set its initial value to <code>0</code>, and finally add
+     * <code>3</code> to it. The result will be a new <i>itemcount</i> attribute in the
+     * item, with a value of <code>3</code>.</p>  </li> <li> <p>If the existing
+     * data type is a set, and if the <code>Value</code> is also a set, then the
+     * <code>Value</code> is added to the existing set. (This is a <i>set</i>
+     * operation, not mathematical addition.) For example, if the attribute value was
+     * the set <code>[1,2]</code>, and the <code>ADD</code> action specified
+     * <code>[3]</code>, then the final attribute value would be <code>[1,2,3]</code>.
+     * An error occurs if an Add action is specified for a set attribute and the
+     * attribute type specified does not match the existing set type. </p> <p>Both sets
+     * must have the same primitive data type. For example, if the existing data type
+     * is a set of strings, the <code>Value</code> must also be a set of strings. The
+     * same holds true for number sets and binary sets.</p> </li> </ul> <p>This action
+     * is only valid for an existing attribute whose data type is number or is a set.
+     * Do not use <code>ADD</code> for any other data types.</p> </li> </ul> <p> <b>If
+     * no item with the specified <i>Key</i> is found:</b> </p> <ul> <li> <p>
+     * <code>PUT</code> - DynamoDB creates a new item with the specified primary key,
+     * and then adds the attribute. </p> </li> <li> <p> <code>DELETE</code> - Nothing
+     * happens; there is no attribute to delete.</p> </li> <li> <p> <code>ADD</code> -
+     * DynamoDB creates an item with the supplied primary key and number (or set of
+     * numbers) for the attribute value. The only data types allowed are number and
+     * number set; no other data types can be specified.</p> </li> </ul>
+     */
+    inline AttributeValueUpdate& WithAction(const AttributeAction& value) { SetAction(value); return *this;}
+
+    /**
+     * <p>Specifies how to perform the update. Valid values are <code>PUT</code>
+     * (default), <code>DELETE</code>, and <code>ADD</code>. The behavior depends on
+     * whether the specified primary key already exists in the table.</p> <p> <b>If an
+     * item with the specified <i>Key</i> is found in the table:</b> </p> <ul> <li> <p>
+     * <code>PUT</code> - Adds the specified attribute to the item. If the attribute
+     * already exists, it is replaced by the new value. </p> </li> <li> <p>
+     * <code>DELETE</code> - If no value is specified, the attribute and its value are
+     * removed from the item. The data type of the specified value must match the
+     * existing value's data type.</p> <p>If a <i>set</i> of values is specified, then
+     * those values are subtracted from the old set. For example, if the attribute
+     * value was the set <code>[a,b,c]</code> and the <code>DELETE</code> action
+     * specified <code>[a,c]</code>, then the final attribute value would be
+     * <code>[b]</code>. Specifying an empty set is an error.</p> </li> <li> <p>
+     * <code>ADD</code> - If the attribute does not already exist, then the attribute
+     * and its values are added to the item. If the attribute does exist, then the
+     * behavior of <code>ADD</code> depends on the data type of the attribute:</p> <ul>
+     * <li> <p>If the existing attribute is a number, and if <code>Value</code> is also
+     * a number, then the <code>Value</code> is mathematically added to the existing
+     * attribute. If <code>Value</code> is a negative number, then it is subtracted
+     * from the existing attribute.</p>  <p> If you use <code>ADD</code> to
+     * increment or decrement a number value for an item that doesn't exist before the
+     * update, DynamoDB uses 0 as the initial value.</p> <p>In addition, if you use
+     * <code>ADD</code> to update an existing item, and intend to increment or
+     * decrement an attribute value which does not yet exist, DynamoDB uses
+     * <code>0</code> as the initial value. For example, suppose that the item you want
+     * to update does not yet have an attribute named <i>itemcount</i>, but you decide
+     * to <code>ADD</code> the number <code>3</code> to this attribute anyway, even
+     * though it currently does not exist. DynamoDB will create the <i>itemcount</i>
+     * attribute, set its initial value to <code>0</code>, and finally add
+     * <code>3</code> to it. The result will be a new <i>itemcount</i> attribute in the
+     * item, with a value of <code>3</code>.</p>  </li> <li> <p>If the existing
+     * data type is a set, and if the <code>Value</code> is also a set, then the
+     * <code>Value</code> is added to the existing set. (This is a <i>set</i>
+     * operation, not mathematical addition.) For example, if the attribute value was
+     * the set <code>[1,2]</code>, and the <code>ADD</code> action specified
+     * <code>[3]</code>, then the final attribute value would be <code>[1,2,3]</code>.
+     * An error occurs if an Add action is specified for a set attribute and the
+     * attribute type specified does not match the existing set type. </p> <p>Both sets
+     * must have the same primitive data type. For example, if the existing data type
+     * is a set of strings, the <code>Value</code> must also be a set of strings. The
+     * same holds true for number sets and binary sets.</p> </li> </ul> <p>This action
+     * is only valid for an existing attribute whose data type is number or is a set.
+     * Do not use <code>ADD</code> for any other data types.</p> </li> </ul> <p> <b>If
+     * no item with the specified <i>Key</i> is found:</b> </p> <ul> <li> <p>
+     * <code>PUT</code> - DynamoDB creates a new item with the specified primary key,
+     * and then adds the attribute. </p> </li> <li> <p> <code>DELETE</code> - Nothing
+     * happens; there is no attribute to delete.</p> </li> <li> <p> <code>ADD</code> -
+     * DynamoDB creates an item with the supplied primary key and number (or set of
+     * numbers) for the attribute value. The only data types allowed are number and
+     * number set; no other data types can be specified.</p> </li> </ul>
+     */
+    inline AttributeValueUpdate& WithAction(AttributeAction&& value) { SetAction(std::move(value)); return *this;}
+
+  private:
+
+    AttributeValue m_value;
+    bool m_valueHasBeenSet;
+
+    AttributeAction m_action;
+    bool m_actionHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/AttributeValueValue.h

@@ -0,0 +1,235 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/model/AttributeValue.h>
+
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <cassert>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+
+class AttributeValue;
+
+class AttributeValueValue
+{
+public:
+    virtual const Aws::String GetS() const { return {}; }
+
+    virtual const Aws::String GetN() const { return {}; }
+
+    virtual const Aws::Utils::ByteBuffer GetB() const { return {}; }
+
+    virtual const Aws::Vector<Aws::String> GetSS() const { return {}; }
+
+    virtual void AddSItem(const Aws::String& ) { assert(false); }
+
+    virtual const Aws::Vector<Aws::String> GetNS() const { return {}; }
+
+    virtual void AddNItem(const Aws::String& ) { assert(false); }
+
+    virtual const Aws::Vector<Aws::Utils::ByteBuffer> GetBS() const { return {}; }
+
+    virtual void AddBItem(const Aws::Utils::ByteBuffer&) { assert(false); }
+
+    virtual const Aws::Map<Aws::String, const std::shared_ptr<AttributeValue>> GetM() const { return {}; }
+
+    virtual void AddMEntry(const Aws::String& , const std::shared_ptr<AttributeValue>& ) { assert(false); }
+
+    virtual const Aws::Vector<std::shared_ptr<AttributeValue>> GetL() const { return {}; }
+
+    virtual void AddLItem(const std::shared_ptr<AttributeValue>& ) { assert(false); }
+
+    virtual bool GetBool() const { return false; }
+
+    virtual bool GetNull() const { return false; }
+
+    virtual bool IsDefault() const = 0;
+
+    virtual bool operator == (const AttributeValueValue& other) const = 0;
+
+    virtual Aws::Utils::Json::JsonValue Jsonize() const = 0;
+
+    virtual ValueType GetType() const = 0;
+};
+
+/// String data type
+class AttributeValueString final : public AttributeValueValue
+{
+public:
+    explicit AttributeValueString(const Aws::String& value) : m_s(value) {}
+    explicit AttributeValueString(Aws::Utils::Json::JsonView jsonValue) : m_s(jsonValue.GetString("S")) {}
+    const Aws::String GetS() const override { return m_s; }
+    bool IsDefault() const override { return m_s.empty(); }
+    bool operator == (const AttributeValueValue& other) const override { return GetType() == other.GetType() && m_s == other.GetS(); }
+    Aws::Utils::Json::JsonValue Jsonize() const override;
+    ValueType GetType() const override { return ValueType::STRING; }
+
+private:
+    Aws::String m_s;
+};
+
+/// Numeric data type
+class AttributeValueNumeric final : public AttributeValueValue
+{
+public:
+    explicit AttributeValueNumeric(const Aws::String& value) : m_n(value) {}
+    explicit AttributeValueNumeric(Aws::Utils::Json::JsonView jsonValue) : m_n(jsonValue.GetString("N")) {}
+    const Aws::String GetN() const override { return m_n; }
+    bool IsDefault() const override { return m_n.empty(); }
+    bool operator == (const AttributeValueValue& other) const override { return GetType() == other.GetType() && m_n == other.GetN(); };
+    Aws::Utils::Json::JsonValue Jsonize() const override;
+    ValueType GetType() const override { return ValueType::NUMBER; }
+
+private:
+    Aws::String m_n;
+};
+
+/// Binary data type
+class AttributeValueByteBuffer final : public AttributeValueValue
+{
+public:
+    explicit AttributeValueByteBuffer(const Aws::Utils::ByteBuffer& value) : m_b(value) {}
+    explicit AttributeValueByteBuffer(Aws::Utils::Json::JsonView jsonValue);
+    const Aws::Utils::ByteBuffer GetB() const override { return m_b; }
+    bool IsDefault() const override { return m_b.GetLength() == 0; }
+    bool operator == (const AttributeValueValue& other) const override { return GetType() == other.GetType() && m_b == other.GetB(); }
+    Aws::Utils::Json::JsonValue Jsonize() const override;
+    ValueType GetType() const override { return ValueType::BYTEBUFFER; }
+
+private:
+    Aws::Utils::ByteBuffer m_b;
+};
+
+/// String set data type
+class AttributeValueStringSet final : public AttributeValueValue
+{
+public:
+    explicit AttributeValueStringSet(const Aws::Vector<Aws::String>& value) : m_sS(value) {}
+    explicit AttributeValueStringSet(Aws::Utils::Json::JsonView jsonValue);
+    const Aws::Vector<Aws::String> GetSS() const override { return m_sS; }
+    void AddSItem(const Aws::String& sItem) override { m_sS.push_back(sItem); }
+    bool IsDefault() const override { return m_sS.empty(); }
+    bool operator == (const AttributeValueValue& other) const override;
+    Aws::Utils::Json::JsonValue Jsonize() const override;
+    ValueType GetType() const override { return ValueType::STRING_SET; }
+
+private:
+    Aws::Vector<Aws::String> m_sS;
+};
+
+/// Number set data type
+class AttributeValueNumberSet final : public AttributeValueValue
+{
+public:
+    explicit AttributeValueNumberSet(const Aws::Vector<Aws::String>& value) : m_nS(value) {}
+    explicit AttributeValueNumberSet(Aws::Utils::Json::JsonView jsonValue);
+    const Aws::Vector<Aws::String> GetNS() const override { return m_nS; }
+    void AddNItem(const Aws::String& nItem) override { m_nS.push_back(nItem); }
+    bool IsDefault() const override { return m_nS.empty(); }
+    bool operator == (const AttributeValueValue& other) const override;
+    Aws::Utils::Json::JsonValue Jsonize() const override;
+    ValueType GetType() const override { return ValueType::NUMBER_SET; }
+
+private:
+    Aws::Vector<Aws::String> m_nS;
+};
+
+/// ByteByffer set data type
+class AttributeValueByteBufferSet final : public AttributeValueValue
+{
+public:
+    explicit AttributeValueByteBufferSet(const Aws::Vector<Aws::Utils::ByteBuffer>& value) : m_bS(value) {}
+    explicit AttributeValueByteBufferSet(Aws::Utils::Json::JsonView jsonValue);
+    const Aws::Vector<Aws::Utils::ByteBuffer> GetBS() const override { return m_bS; }
+    void AddBItem(const Aws::Utils::ByteBuffer& bItem) override { m_bS.push_back(bItem); }
+    bool IsDefault() const override { return m_bS.empty(); }
+    bool operator == (const AttributeValueValue& other) const override;
+    Aws::Utils::Json::JsonValue Jsonize() const override;
+    ValueType GetType() const override { return ValueType::BYTEBUFFER_SET; }
+
+private:
+    Aws::Vector<Aws::Utils::ByteBuffer> m_bS;
+};
+
+/// Map Attribute Type
+class AttributeValueMap final : public AttributeValueValue
+{
+public:
+    explicit AttributeValueMap(const Aws::Map<Aws::String, const std::shared_ptr<AttributeValue>>& value) : m_m(value) {}
+    explicit AttributeValueMap(Aws::Utils::Json::JsonView jsonValue);
+    const Aws::Map<Aws::String, const std::shared_ptr<AttributeValue>> GetM() const override{ return m_m; }
+    void AddMEntry(const Aws::String& key, const std::shared_ptr<AttributeValue>& value) override;
+    bool IsDefault() const override { return m_m.empty(); }
+    bool operator == (const AttributeValueValue& other) const override;
+    Aws::Utils::Json::JsonValue Jsonize() const override;
+    ValueType GetType() const override { return ValueType::ATTRIBUTE_MAP; }
+
+private:
+    Aws::Map<Aws::String, const std::shared_ptr<AttributeValue>> m_m;
+};
+
+/// List Attribute Type
+class AttributeValueList final : public AttributeValueValue
+{
+public:
+    explicit AttributeValueList(const Aws::Vector<std::shared_ptr<AttributeValue>>& value) : m_l(value) {}
+    explicit AttributeValueList(Aws::Utils::Json::JsonView jsonValue);
+    const Aws::Vector<std::shared_ptr<AttributeValue>> GetL() const override { return m_l; }
+    void AddLItem(const std::shared_ptr<AttributeValue>& listItem) override { m_l.push_back(listItem); }
+    bool IsDefault() const override { return m_l.empty(); }
+    bool operator == (const AttributeValueValue& other) const override;
+    Aws::Utils::Json::JsonValue Jsonize() const override;
+    ValueType GetType() const override { return ValueType::ATTRIBUTE_LIST; }
+
+private:
+    Aws::Vector<std::shared_ptr<AttributeValue>> m_l;
+};
+
+/// Bool type
+class AttributeValueBool final : public AttributeValueValue
+{
+public:
+    explicit AttributeValueBool(bool value) : m_bool(value) {}
+    explicit AttributeValueBool(Aws::Utils::Json::JsonView jsonValue) : m_bool(jsonValue.GetBool("BOOL")) {}
+    bool GetBool() const override { return m_bool; }
+    bool IsDefault() const override { return m_bool == false; }
+    bool operator == (const AttributeValueValue& other) const override { return GetType() == other.GetType() && m_bool == other.GetBool(); }
+    Aws::Utils::Json::JsonValue Jsonize() const override;
+    ValueType GetType() const override { return ValueType::BOOL; }
+
+private:
+    bool m_bool;
+};
+
+/// NULL type
+class AttributeValueNull final : public AttributeValueValue
+{
+public:
+    explicit AttributeValueNull(bool value) : m_null(value) {}
+    explicit AttributeValueNull(Aws::Utils::Json::JsonView jsonValue) : m_null(jsonValue.GetBool("NULL")) {}
+    bool GetNull() const override { return m_null; }
+    bool IsDefault() const override { return m_null == false; }
+    bool operator == (const AttributeValueValue& other) const override { return GetType() == other.GetType() && m_null == other.GetNull(); }
+    Aws::Utils::Json::JsonValue Jsonize() const override;
+    ValueType GetType() const override { return ValueType::NULLVALUE; }
+
+private:
+    bool m_null;
+};
+
+} // Model
+} // DynamoDB
+} // Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/AutoScalingPolicyDescription.h

@@ -0,0 +1,124 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/dynamodb/model/AutoScalingTargetTrackingScalingPolicyConfigurationDescription.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents the properties of the scaling policy.</p><p><h3>See Also:</h3>  
+   * <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/AutoScalingPolicyDescription">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API AutoScalingPolicyDescription
+  {
+  public:
+    AutoScalingPolicyDescription();
+    AutoScalingPolicyDescription(Aws::Utils::Json::JsonView jsonValue);
+    AutoScalingPolicyDescription& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The name of the scaling policy.</p>
+     */
+    inline const Aws::String& GetPolicyName() const{ return m_policyName; }
+
+    /**
+     * <p>The name of the scaling policy.</p>
+     */
+    inline bool PolicyNameHasBeenSet() const { return m_policyNameHasBeenSet; }
+
+    /**
+     * <p>The name of the scaling policy.</p>
+     */
+    inline void SetPolicyName(const Aws::String& value) { m_policyNameHasBeenSet = true; m_policyName = value; }
+
+    /**
+     * <p>The name of the scaling policy.</p>
+     */
+    inline void SetPolicyName(Aws::String&& value) { m_policyNameHasBeenSet = true; m_policyName = std::move(value); }
+
+    /**
+     * <p>The name of the scaling policy.</p>
+     */
+    inline void SetPolicyName(const char* value) { m_policyNameHasBeenSet = true; m_policyName.assign(value); }
+
+    /**
+     * <p>The name of the scaling policy.</p>
+     */
+    inline AutoScalingPolicyDescription& WithPolicyName(const Aws::String& value) { SetPolicyName(value); return *this;}
+
+    /**
+     * <p>The name of the scaling policy.</p>
+     */
+    inline AutoScalingPolicyDescription& WithPolicyName(Aws::String&& value) { SetPolicyName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the scaling policy.</p>
+     */
+    inline AutoScalingPolicyDescription& WithPolicyName(const char* value) { SetPolicyName(value); return *this;}
+
+
+    /**
+     * <p>Represents a target tracking scaling policy configuration.</p>
+     */
+    inline const AutoScalingTargetTrackingScalingPolicyConfigurationDescription& GetTargetTrackingScalingPolicyConfiguration() const{ return m_targetTrackingScalingPolicyConfiguration; }
+
+    /**
+     * <p>Represents a target tracking scaling policy configuration.</p>
+     */
+    inline bool TargetTrackingScalingPolicyConfigurationHasBeenSet() const { return m_targetTrackingScalingPolicyConfigurationHasBeenSet; }
+
+    /**
+     * <p>Represents a target tracking scaling policy configuration.</p>
+     */
+    inline void SetTargetTrackingScalingPolicyConfiguration(const AutoScalingTargetTrackingScalingPolicyConfigurationDescription& value) { m_targetTrackingScalingPolicyConfigurationHasBeenSet = true; m_targetTrackingScalingPolicyConfiguration = value; }
+
+    /**
+     * <p>Represents a target tracking scaling policy configuration.</p>
+     */
+    inline void SetTargetTrackingScalingPolicyConfiguration(AutoScalingTargetTrackingScalingPolicyConfigurationDescription&& value) { m_targetTrackingScalingPolicyConfigurationHasBeenSet = true; m_targetTrackingScalingPolicyConfiguration = std::move(value); }
+
+    /**
+     * <p>Represents a target tracking scaling policy configuration.</p>
+     */
+    inline AutoScalingPolicyDescription& WithTargetTrackingScalingPolicyConfiguration(const AutoScalingTargetTrackingScalingPolicyConfigurationDescription& value) { SetTargetTrackingScalingPolicyConfiguration(value); return *this;}
+
+    /**
+     * <p>Represents a target tracking scaling policy configuration.</p>
+     */
+    inline AutoScalingPolicyDescription& WithTargetTrackingScalingPolicyConfiguration(AutoScalingTargetTrackingScalingPolicyConfigurationDescription&& value) { SetTargetTrackingScalingPolicyConfiguration(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_policyName;
+    bool m_policyNameHasBeenSet;
+
+    AutoScalingTargetTrackingScalingPolicyConfigurationDescription m_targetTrackingScalingPolicyConfiguration;
+    bool m_targetTrackingScalingPolicyConfigurationHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/AutoScalingPolicyUpdate.h

@@ -0,0 +1,124 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/dynamodb/model/AutoScalingTargetTrackingScalingPolicyConfigurationUpdate.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents the auto scaling policy to be modified.</p><p><h3>See Also:</h3>  
+   * <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/AutoScalingPolicyUpdate">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API AutoScalingPolicyUpdate
+  {
+  public:
+    AutoScalingPolicyUpdate();
+    AutoScalingPolicyUpdate(Aws::Utils::Json::JsonView jsonValue);
+    AutoScalingPolicyUpdate& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The name of the scaling policy.</p>
+     */
+    inline const Aws::String& GetPolicyName() const{ return m_policyName; }
+
+    /**
+     * <p>The name of the scaling policy.</p>
+     */
+    inline bool PolicyNameHasBeenSet() const { return m_policyNameHasBeenSet; }
+
+    /**
+     * <p>The name of the scaling policy.</p>
+     */
+    inline void SetPolicyName(const Aws::String& value) { m_policyNameHasBeenSet = true; m_policyName = value; }
+
+    /**
+     * <p>The name of the scaling policy.</p>
+     */
+    inline void SetPolicyName(Aws::String&& value) { m_policyNameHasBeenSet = true; m_policyName = std::move(value); }
+
+    /**
+     * <p>The name of the scaling policy.</p>
+     */
+    inline void SetPolicyName(const char* value) { m_policyNameHasBeenSet = true; m_policyName.assign(value); }
+
+    /**
+     * <p>The name of the scaling policy.</p>
+     */
+    inline AutoScalingPolicyUpdate& WithPolicyName(const Aws::String& value) { SetPolicyName(value); return *this;}
+
+    /**
+     * <p>The name of the scaling policy.</p>
+     */
+    inline AutoScalingPolicyUpdate& WithPolicyName(Aws::String&& value) { SetPolicyName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the scaling policy.</p>
+     */
+    inline AutoScalingPolicyUpdate& WithPolicyName(const char* value) { SetPolicyName(value); return *this;}
+
+
+    /**
+     * <p>Represents a target tracking scaling policy configuration.</p>
+     */
+    inline const AutoScalingTargetTrackingScalingPolicyConfigurationUpdate& GetTargetTrackingScalingPolicyConfiguration() const{ return m_targetTrackingScalingPolicyConfiguration; }
+
+    /**
+     * <p>Represents a target tracking scaling policy configuration.</p>
+     */
+    inline bool TargetTrackingScalingPolicyConfigurationHasBeenSet() const { return m_targetTrackingScalingPolicyConfigurationHasBeenSet; }
+
+    /**
+     * <p>Represents a target tracking scaling policy configuration.</p>
+     */
+    inline void SetTargetTrackingScalingPolicyConfiguration(const AutoScalingTargetTrackingScalingPolicyConfigurationUpdate& value) { m_targetTrackingScalingPolicyConfigurationHasBeenSet = true; m_targetTrackingScalingPolicyConfiguration = value; }
+
+    /**
+     * <p>Represents a target tracking scaling policy configuration.</p>
+     */
+    inline void SetTargetTrackingScalingPolicyConfiguration(AutoScalingTargetTrackingScalingPolicyConfigurationUpdate&& value) { m_targetTrackingScalingPolicyConfigurationHasBeenSet = true; m_targetTrackingScalingPolicyConfiguration = std::move(value); }
+
+    /**
+     * <p>Represents a target tracking scaling policy configuration.</p>
+     */
+    inline AutoScalingPolicyUpdate& WithTargetTrackingScalingPolicyConfiguration(const AutoScalingTargetTrackingScalingPolicyConfigurationUpdate& value) { SetTargetTrackingScalingPolicyConfiguration(value); return *this;}
+
+    /**
+     * <p>Represents a target tracking scaling policy configuration.</p>
+     */
+    inline AutoScalingPolicyUpdate& WithTargetTrackingScalingPolicyConfiguration(AutoScalingTargetTrackingScalingPolicyConfigurationUpdate&& value) { SetTargetTrackingScalingPolicyConfiguration(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_policyName;
+    bool m_policyNameHasBeenSet;
+
+    AutoScalingTargetTrackingScalingPolicyConfigurationUpdate m_targetTrackingScalingPolicyConfiguration;
+    bool m_targetTrackingScalingPolicyConfigurationHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/AutoScalingSettingsDescription.h

@@ -0,0 +1,215 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/dynamodb/model/AutoScalingPolicyDescription.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents the auto scaling settings for a global table or global secondary
+   * index.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/AutoScalingSettingsDescription">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API AutoScalingSettingsDescription
+  {
+  public:
+    AutoScalingSettingsDescription();
+    AutoScalingSettingsDescription(Aws::Utils::Json::JsonView jsonValue);
+    AutoScalingSettingsDescription& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The minimum capacity units that a global table or global secondary index
+     * should be scaled down to.</p>
+     */
+    inline long long GetMinimumUnits() const{ return m_minimumUnits; }
+
+    /**
+     * <p>The minimum capacity units that a global table or global secondary index
+     * should be scaled down to.</p>
+     */
+    inline bool MinimumUnitsHasBeenSet() const { return m_minimumUnitsHasBeenSet; }
+
+    /**
+     * <p>The minimum capacity units that a global table or global secondary index
+     * should be scaled down to.</p>
+     */
+    inline void SetMinimumUnits(long long value) { m_minimumUnitsHasBeenSet = true; m_minimumUnits = value; }
+
+    /**
+     * <p>The minimum capacity units that a global table or global secondary index
+     * should be scaled down to.</p>
+     */
+    inline AutoScalingSettingsDescription& WithMinimumUnits(long long value) { SetMinimumUnits(value); return *this;}
+
+
+    /**
+     * <p>The maximum capacity units that a global table or global secondary index
+     * should be scaled up to.</p>
+     */
+    inline long long GetMaximumUnits() const{ return m_maximumUnits; }
+
+    /**
+     * <p>The maximum capacity units that a global table or global secondary index
+     * should be scaled up to.</p>
+     */
+    inline bool MaximumUnitsHasBeenSet() const { return m_maximumUnitsHasBeenSet; }
+
+    /**
+     * <p>The maximum capacity units that a global table or global secondary index
+     * should be scaled up to.</p>
+     */
+    inline void SetMaximumUnits(long long value) { m_maximumUnitsHasBeenSet = true; m_maximumUnits = value; }
+
+    /**
+     * <p>The maximum capacity units that a global table or global secondary index
+     * should be scaled up to.</p>
+     */
+    inline AutoScalingSettingsDescription& WithMaximumUnits(long long value) { SetMaximumUnits(value); return *this;}
+
+
+    /**
+     * <p>Disabled auto scaling for this global table or global secondary index.</p>
+     */
+    inline bool GetAutoScalingDisabled() const{ return m_autoScalingDisabled; }
+
+    /**
+     * <p>Disabled auto scaling for this global table or global secondary index.</p>
+     */
+    inline bool AutoScalingDisabledHasBeenSet() const { return m_autoScalingDisabledHasBeenSet; }
+
+    /**
+     * <p>Disabled auto scaling for this global table or global secondary index.</p>
+     */
+    inline void SetAutoScalingDisabled(bool value) { m_autoScalingDisabledHasBeenSet = true; m_autoScalingDisabled = value; }
+
+    /**
+     * <p>Disabled auto scaling for this global table or global secondary index.</p>
+     */
+    inline AutoScalingSettingsDescription& WithAutoScalingDisabled(bool value) { SetAutoScalingDisabled(value); return *this;}
+
+
+    /**
+     * <p>Role ARN used for configuring the auto scaling policy.</p>
+     */
+    inline const Aws::String& GetAutoScalingRoleArn() const{ return m_autoScalingRoleArn; }
+
+    /**
+     * <p>Role ARN used for configuring the auto scaling policy.</p>
+     */
+    inline bool AutoScalingRoleArnHasBeenSet() const { return m_autoScalingRoleArnHasBeenSet; }
+
+    /**
+     * <p>Role ARN used for configuring the auto scaling policy.</p>
+     */
+    inline void SetAutoScalingRoleArn(const Aws::String& value) { m_autoScalingRoleArnHasBeenSet = true; m_autoScalingRoleArn = value; }
+
+    /**
+     * <p>Role ARN used for configuring the auto scaling policy.</p>
+     */
+    inline void SetAutoScalingRoleArn(Aws::String&& value) { m_autoScalingRoleArnHasBeenSet = true; m_autoScalingRoleArn = std::move(value); }
+
+    /**
+     * <p>Role ARN used for configuring the auto scaling policy.</p>
+     */
+    inline void SetAutoScalingRoleArn(const char* value) { m_autoScalingRoleArnHasBeenSet = true; m_autoScalingRoleArn.assign(value); }
+
+    /**
+     * <p>Role ARN used for configuring the auto scaling policy.</p>
+     */
+    inline AutoScalingSettingsDescription& WithAutoScalingRoleArn(const Aws::String& value) { SetAutoScalingRoleArn(value); return *this;}
+
+    /**
+     * <p>Role ARN used for configuring the auto scaling policy.</p>
+     */
+    inline AutoScalingSettingsDescription& WithAutoScalingRoleArn(Aws::String&& value) { SetAutoScalingRoleArn(std::move(value)); return *this;}
+
+    /**
+     * <p>Role ARN used for configuring the auto scaling policy.</p>
+     */
+    inline AutoScalingSettingsDescription& WithAutoScalingRoleArn(const char* value) { SetAutoScalingRoleArn(value); return *this;}
+
+
+    /**
+     * <p>Information about the scaling policies.</p>
+     */
+    inline const Aws::Vector<AutoScalingPolicyDescription>& GetScalingPolicies() const{ return m_scalingPolicies; }
+
+    /**
+     * <p>Information about the scaling policies.</p>
+     */
+    inline bool ScalingPoliciesHasBeenSet() const { return m_scalingPoliciesHasBeenSet; }
+
+    /**
+     * <p>Information about the scaling policies.</p>
+     */
+    inline void SetScalingPolicies(const Aws::Vector<AutoScalingPolicyDescription>& value) { m_scalingPoliciesHasBeenSet = true; m_scalingPolicies = value; }
+
+    /**
+     * <p>Information about the scaling policies.</p>
+     */
+    inline void SetScalingPolicies(Aws::Vector<AutoScalingPolicyDescription>&& value) { m_scalingPoliciesHasBeenSet = true; m_scalingPolicies = std::move(value); }
+
+    /**
+     * <p>Information about the scaling policies.</p>
+     */
+    inline AutoScalingSettingsDescription& WithScalingPolicies(const Aws::Vector<AutoScalingPolicyDescription>& value) { SetScalingPolicies(value); return *this;}
+
+    /**
+     * <p>Information about the scaling policies.</p>
+     */
+    inline AutoScalingSettingsDescription& WithScalingPolicies(Aws::Vector<AutoScalingPolicyDescription>&& value) { SetScalingPolicies(std::move(value)); return *this;}
+
+    /**
+     * <p>Information about the scaling policies.</p>
+     */
+    inline AutoScalingSettingsDescription& AddScalingPolicies(const AutoScalingPolicyDescription& value) { m_scalingPoliciesHasBeenSet = true; m_scalingPolicies.push_back(value); return *this; }
+
+    /**
+     * <p>Information about the scaling policies.</p>
+     */
+    inline AutoScalingSettingsDescription& AddScalingPolicies(AutoScalingPolicyDescription&& value) { m_scalingPoliciesHasBeenSet = true; m_scalingPolicies.push_back(std::move(value)); return *this; }
+
+  private:
+
+    long long m_minimumUnits;
+    bool m_minimumUnitsHasBeenSet;
+
+    long long m_maximumUnits;
+    bool m_maximumUnitsHasBeenSet;
+
+    bool m_autoScalingDisabled;
+    bool m_autoScalingDisabledHasBeenSet;
+
+    Aws::String m_autoScalingRoleArn;
+    bool m_autoScalingRoleArnHasBeenSet;
+
+    Aws::Vector<AutoScalingPolicyDescription> m_scalingPolicies;
+    bool m_scalingPoliciesHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/AutoScalingSettingsUpdate.h

@@ -0,0 +1,210 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/dynamodb/model/AutoScalingPolicyUpdate.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents the auto scaling settings to be modified for a global table or
+   * global secondary index.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/AutoScalingSettingsUpdate">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API AutoScalingSettingsUpdate
+  {
+  public:
+    AutoScalingSettingsUpdate();
+    AutoScalingSettingsUpdate(Aws::Utils::Json::JsonView jsonValue);
+    AutoScalingSettingsUpdate& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The minimum capacity units that a global table or global secondary index
+     * should be scaled down to.</p>
+     */
+    inline long long GetMinimumUnits() const{ return m_minimumUnits; }
+
+    /**
+     * <p>The minimum capacity units that a global table or global secondary index
+     * should be scaled down to.</p>
+     */
+    inline bool MinimumUnitsHasBeenSet() const { return m_minimumUnitsHasBeenSet; }
+
+    /**
+     * <p>The minimum capacity units that a global table or global secondary index
+     * should be scaled down to.</p>
+     */
+    inline void SetMinimumUnits(long long value) { m_minimumUnitsHasBeenSet = true; m_minimumUnits = value; }
+
+    /**
+     * <p>The minimum capacity units that a global table or global secondary index
+     * should be scaled down to.</p>
+     */
+    inline AutoScalingSettingsUpdate& WithMinimumUnits(long long value) { SetMinimumUnits(value); return *this;}
+
+
+    /**
+     * <p>The maximum capacity units that a global table or global secondary index
+     * should be scaled up to.</p>
+     */
+    inline long long GetMaximumUnits() const{ return m_maximumUnits; }
+
+    /**
+     * <p>The maximum capacity units that a global table or global secondary index
+     * should be scaled up to.</p>
+     */
+    inline bool MaximumUnitsHasBeenSet() const { return m_maximumUnitsHasBeenSet; }
+
+    /**
+     * <p>The maximum capacity units that a global table or global secondary index
+     * should be scaled up to.</p>
+     */
+    inline void SetMaximumUnits(long long value) { m_maximumUnitsHasBeenSet = true; m_maximumUnits = value; }
+
+    /**
+     * <p>The maximum capacity units that a global table or global secondary index
+     * should be scaled up to.</p>
+     */
+    inline AutoScalingSettingsUpdate& WithMaximumUnits(long long value) { SetMaximumUnits(value); return *this;}
+
+
+    /**
+     * <p>Disabled auto scaling for this global table or global secondary index.</p>
+     */
+    inline bool GetAutoScalingDisabled() const{ return m_autoScalingDisabled; }
+
+    /**
+     * <p>Disabled auto scaling for this global table or global secondary index.</p>
+     */
+    inline bool AutoScalingDisabledHasBeenSet() const { return m_autoScalingDisabledHasBeenSet; }
+
+    /**
+     * <p>Disabled auto scaling for this global table or global secondary index.</p>
+     */
+    inline void SetAutoScalingDisabled(bool value) { m_autoScalingDisabledHasBeenSet = true; m_autoScalingDisabled = value; }
+
+    /**
+     * <p>Disabled auto scaling for this global table or global secondary index.</p>
+     */
+    inline AutoScalingSettingsUpdate& WithAutoScalingDisabled(bool value) { SetAutoScalingDisabled(value); return *this;}
+
+
+    /**
+     * <p>Role ARN used for configuring auto scaling policy.</p>
+     */
+    inline const Aws::String& GetAutoScalingRoleArn() const{ return m_autoScalingRoleArn; }
+
+    /**
+     * <p>Role ARN used for configuring auto scaling policy.</p>
+     */
+    inline bool AutoScalingRoleArnHasBeenSet() const { return m_autoScalingRoleArnHasBeenSet; }
+
+    /**
+     * <p>Role ARN used for configuring auto scaling policy.</p>
+     */
+    inline void SetAutoScalingRoleArn(const Aws::String& value) { m_autoScalingRoleArnHasBeenSet = true; m_autoScalingRoleArn = value; }
+
+    /**
+     * <p>Role ARN used for configuring auto scaling policy.</p>
+     */
+    inline void SetAutoScalingRoleArn(Aws::String&& value) { m_autoScalingRoleArnHasBeenSet = true; m_autoScalingRoleArn = std::move(value); }
+
+    /**
+     * <p>Role ARN used for configuring auto scaling policy.</p>
+     */
+    inline void SetAutoScalingRoleArn(const char* value) { m_autoScalingRoleArnHasBeenSet = true; m_autoScalingRoleArn.assign(value); }
+
+    /**
+     * <p>Role ARN used for configuring auto scaling policy.</p>
+     */
+    inline AutoScalingSettingsUpdate& WithAutoScalingRoleArn(const Aws::String& value) { SetAutoScalingRoleArn(value); return *this;}
+
+    /**
+     * <p>Role ARN used for configuring auto scaling policy.</p>
+     */
+    inline AutoScalingSettingsUpdate& WithAutoScalingRoleArn(Aws::String&& value) { SetAutoScalingRoleArn(std::move(value)); return *this;}
+
+    /**
+     * <p>Role ARN used for configuring auto scaling policy.</p>
+     */
+    inline AutoScalingSettingsUpdate& WithAutoScalingRoleArn(const char* value) { SetAutoScalingRoleArn(value); return *this;}
+
+
+    /**
+     * <p>The scaling policy to apply for scaling target global table or global
+     * secondary index capacity units.</p>
+     */
+    inline const AutoScalingPolicyUpdate& GetScalingPolicyUpdate() const{ return m_scalingPolicyUpdate; }
+
+    /**
+     * <p>The scaling policy to apply for scaling target global table or global
+     * secondary index capacity units.</p>
+     */
+    inline bool ScalingPolicyUpdateHasBeenSet() const { return m_scalingPolicyUpdateHasBeenSet; }
+
+    /**
+     * <p>The scaling policy to apply for scaling target global table or global
+     * secondary index capacity units.</p>
+     */
+    inline void SetScalingPolicyUpdate(const AutoScalingPolicyUpdate& value) { m_scalingPolicyUpdateHasBeenSet = true; m_scalingPolicyUpdate = value; }
+
+    /**
+     * <p>The scaling policy to apply for scaling target global table or global
+     * secondary index capacity units.</p>
+     */
+    inline void SetScalingPolicyUpdate(AutoScalingPolicyUpdate&& value) { m_scalingPolicyUpdateHasBeenSet = true; m_scalingPolicyUpdate = std::move(value); }
+
+    /**
+     * <p>The scaling policy to apply for scaling target global table or global
+     * secondary index capacity units.</p>
+     */
+    inline AutoScalingSettingsUpdate& WithScalingPolicyUpdate(const AutoScalingPolicyUpdate& value) { SetScalingPolicyUpdate(value); return *this;}
+
+    /**
+     * <p>The scaling policy to apply for scaling target global table or global
+     * secondary index capacity units.</p>
+     */
+    inline AutoScalingSettingsUpdate& WithScalingPolicyUpdate(AutoScalingPolicyUpdate&& value) { SetScalingPolicyUpdate(std::move(value)); return *this;}
+
+  private:
+
+    long long m_minimumUnits;
+    bool m_minimumUnitsHasBeenSet;
+
+    long long m_maximumUnits;
+    bool m_maximumUnitsHasBeenSet;
+
+    bool m_autoScalingDisabled;
+    bool m_autoScalingDisabledHasBeenSet;
+
+    Aws::String m_autoScalingRoleArn;
+    bool m_autoScalingRoleArnHasBeenSet;
+
+    AutoScalingPolicyUpdate m_scalingPolicyUpdate;
+    bool m_scalingPolicyUpdateHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/AutoScalingTargetTrackingScalingPolicyConfigurationDescription.h

@@ -0,0 +1,195 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents the properties of a target tracking scaling policy.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/AutoScalingTargetTrackingScalingPolicyConfigurationDescription">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API AutoScalingTargetTrackingScalingPolicyConfigurationDescription
+  {
+  public:
+    AutoScalingTargetTrackingScalingPolicyConfigurationDescription();
+    AutoScalingTargetTrackingScalingPolicyConfigurationDescription(Aws::Utils::Json::JsonView jsonValue);
+    AutoScalingTargetTrackingScalingPolicyConfigurationDescription& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Indicates whether scale in by the target tracking policy is disabled. If the
+     * value is true, scale in is disabled and the target tracking policy won't remove
+     * capacity from the scalable resource. Otherwise, scale in is enabled and the
+     * target tracking policy can remove capacity from the scalable resource. The
+     * default value is false.</p>
+     */
+    inline bool GetDisableScaleIn() const{ return m_disableScaleIn; }
+
+    /**
+     * <p>Indicates whether scale in by the target tracking policy is disabled. If the
+     * value is true, scale in is disabled and the target tracking policy won't remove
+     * capacity from the scalable resource. Otherwise, scale in is enabled and the
+     * target tracking policy can remove capacity from the scalable resource. The
+     * default value is false.</p>
+     */
+    inline bool DisableScaleInHasBeenSet() const { return m_disableScaleInHasBeenSet; }
+
+    /**
+     * <p>Indicates whether scale in by the target tracking policy is disabled. If the
+     * value is true, scale in is disabled and the target tracking policy won't remove
+     * capacity from the scalable resource. Otherwise, scale in is enabled and the
+     * target tracking policy can remove capacity from the scalable resource. The
+     * default value is false.</p>
+     */
+    inline void SetDisableScaleIn(bool value) { m_disableScaleInHasBeenSet = true; m_disableScaleIn = value; }
+
+    /**
+     * <p>Indicates whether scale in by the target tracking policy is disabled. If the
+     * value is true, scale in is disabled and the target tracking policy won't remove
+     * capacity from the scalable resource. Otherwise, scale in is enabled and the
+     * target tracking policy can remove capacity from the scalable resource. The
+     * default value is false.</p>
+     */
+    inline AutoScalingTargetTrackingScalingPolicyConfigurationDescription& WithDisableScaleIn(bool value) { SetDisableScaleIn(value); return *this;}
+
+
+    /**
+     * <p>The amount of time, in seconds, after a scale in activity completes before
+     * another scale in activity can start. The cooldown period is used to block
+     * subsequent scale in requests until it has expired. You should scale in
+     * conservatively to protect your application's availability. However, if another
+     * alarm triggers a scale out policy during the cooldown period after a scale-in,
+     * application auto scaling scales out your scalable target immediately. </p>
+     */
+    inline int GetScaleInCooldown() const{ return m_scaleInCooldown; }
+
+    /**
+     * <p>The amount of time, in seconds, after a scale in activity completes before
+     * another scale in activity can start. The cooldown period is used to block
+     * subsequent scale in requests until it has expired. You should scale in
+     * conservatively to protect your application's availability. However, if another
+     * alarm triggers a scale out policy during the cooldown period after a scale-in,
+     * application auto scaling scales out your scalable target immediately. </p>
+     */
+    inline bool ScaleInCooldownHasBeenSet() const { return m_scaleInCooldownHasBeenSet; }
+
+    /**
+     * <p>The amount of time, in seconds, after a scale in activity completes before
+     * another scale in activity can start. The cooldown period is used to block
+     * subsequent scale in requests until it has expired. You should scale in
+     * conservatively to protect your application's availability. However, if another
+     * alarm triggers a scale out policy during the cooldown period after a scale-in,
+     * application auto scaling scales out your scalable target immediately. </p>
+     */
+    inline void SetScaleInCooldown(int value) { m_scaleInCooldownHasBeenSet = true; m_scaleInCooldown = value; }
+
+    /**
+     * <p>The amount of time, in seconds, after a scale in activity completes before
+     * another scale in activity can start. The cooldown period is used to block
+     * subsequent scale in requests until it has expired. You should scale in
+     * conservatively to protect your application's availability. However, if another
+     * alarm triggers a scale out policy during the cooldown period after a scale-in,
+     * application auto scaling scales out your scalable target immediately. </p>
+     */
+    inline AutoScalingTargetTrackingScalingPolicyConfigurationDescription& WithScaleInCooldown(int value) { SetScaleInCooldown(value); return *this;}
+
+
+    /**
+     * <p>The amount of time, in seconds, after a scale out activity completes before
+     * another scale out activity can start. While the cooldown period is in effect,
+     * the capacity that has been added by the previous scale out event that initiated
+     * the cooldown is calculated as part of the desired capacity for the next scale
+     * out. You should continuously (but not excessively) scale out.</p>
+     */
+    inline int GetScaleOutCooldown() const{ return m_scaleOutCooldown; }
+
+    /**
+     * <p>The amount of time, in seconds, after a scale out activity completes before
+     * another scale out activity can start. While the cooldown period is in effect,
+     * the capacity that has been added by the previous scale out event that initiated
+     * the cooldown is calculated as part of the desired capacity for the next scale
+     * out. You should continuously (but not excessively) scale out.</p>
+     */
+    inline bool ScaleOutCooldownHasBeenSet() const { return m_scaleOutCooldownHasBeenSet; }
+
+    /**
+     * <p>The amount of time, in seconds, after a scale out activity completes before
+     * another scale out activity can start. While the cooldown period is in effect,
+     * the capacity that has been added by the previous scale out event that initiated
+     * the cooldown is calculated as part of the desired capacity for the next scale
+     * out. You should continuously (but not excessively) scale out.</p>
+     */
+    inline void SetScaleOutCooldown(int value) { m_scaleOutCooldownHasBeenSet = true; m_scaleOutCooldown = value; }
+
+    /**
+     * <p>The amount of time, in seconds, after a scale out activity completes before
+     * another scale out activity can start. While the cooldown period is in effect,
+     * the capacity that has been added by the previous scale out event that initiated
+     * the cooldown is calculated as part of the desired capacity for the next scale
+     * out. You should continuously (but not excessively) scale out.</p>
+     */
+    inline AutoScalingTargetTrackingScalingPolicyConfigurationDescription& WithScaleOutCooldown(int value) { SetScaleOutCooldown(value); return *this;}
+
+
+    /**
+     * <p>The target value for the metric. The range is 8.515920e-109 to 1.174271e+108
+     * (Base 10) or 2e-360 to 2e360 (Base 2).</p>
+     */
+    inline double GetTargetValue() const{ return m_targetValue; }
+
+    /**
+     * <p>The target value for the metric. The range is 8.515920e-109 to 1.174271e+108
+     * (Base 10) or 2e-360 to 2e360 (Base 2).</p>
+     */
+    inline bool TargetValueHasBeenSet() const { return m_targetValueHasBeenSet; }
+
+    /**
+     * <p>The target value for the metric. The range is 8.515920e-109 to 1.174271e+108
+     * (Base 10) or 2e-360 to 2e360 (Base 2).</p>
+     */
+    inline void SetTargetValue(double value) { m_targetValueHasBeenSet = true; m_targetValue = value; }
+
+    /**
+     * <p>The target value for the metric. The range is 8.515920e-109 to 1.174271e+108
+     * (Base 10) or 2e-360 to 2e360 (Base 2).</p>
+     */
+    inline AutoScalingTargetTrackingScalingPolicyConfigurationDescription& WithTargetValue(double value) { SetTargetValue(value); return *this;}
+
+  private:
+
+    bool m_disableScaleIn;
+    bool m_disableScaleInHasBeenSet;
+
+    int m_scaleInCooldown;
+    bool m_scaleInCooldownHasBeenSet;
+
+    int m_scaleOutCooldown;
+    bool m_scaleOutCooldownHasBeenSet;
+
+    double m_targetValue;
+    bool m_targetValueHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/AutoScalingTargetTrackingScalingPolicyConfigurationUpdate.h

@@ -0,0 +1,195 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents the settings of a target tracking scaling policy that will be
+   * modified.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/AutoScalingTargetTrackingScalingPolicyConfigurationUpdate">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API AutoScalingTargetTrackingScalingPolicyConfigurationUpdate
+  {
+  public:
+    AutoScalingTargetTrackingScalingPolicyConfigurationUpdate();
+    AutoScalingTargetTrackingScalingPolicyConfigurationUpdate(Aws::Utils::Json::JsonView jsonValue);
+    AutoScalingTargetTrackingScalingPolicyConfigurationUpdate& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Indicates whether scale in by the target tracking policy is disabled. If the
+     * value is true, scale in is disabled and the target tracking policy won't remove
+     * capacity from the scalable resource. Otherwise, scale in is enabled and the
+     * target tracking policy can remove capacity from the scalable resource. The
+     * default value is false.</p>
+     */
+    inline bool GetDisableScaleIn() const{ return m_disableScaleIn; }
+
+    /**
+     * <p>Indicates whether scale in by the target tracking policy is disabled. If the
+     * value is true, scale in is disabled and the target tracking policy won't remove
+     * capacity from the scalable resource. Otherwise, scale in is enabled and the
+     * target tracking policy can remove capacity from the scalable resource. The
+     * default value is false.</p>
+     */
+    inline bool DisableScaleInHasBeenSet() const { return m_disableScaleInHasBeenSet; }
+
+    /**
+     * <p>Indicates whether scale in by the target tracking policy is disabled. If the
+     * value is true, scale in is disabled and the target tracking policy won't remove
+     * capacity from the scalable resource. Otherwise, scale in is enabled and the
+     * target tracking policy can remove capacity from the scalable resource. The
+     * default value is false.</p>
+     */
+    inline void SetDisableScaleIn(bool value) { m_disableScaleInHasBeenSet = true; m_disableScaleIn = value; }
+
+    /**
+     * <p>Indicates whether scale in by the target tracking policy is disabled. If the
+     * value is true, scale in is disabled and the target tracking policy won't remove
+     * capacity from the scalable resource. Otherwise, scale in is enabled and the
+     * target tracking policy can remove capacity from the scalable resource. The
+     * default value is false.</p>
+     */
+    inline AutoScalingTargetTrackingScalingPolicyConfigurationUpdate& WithDisableScaleIn(bool value) { SetDisableScaleIn(value); return *this;}
+
+
+    /**
+     * <p>The amount of time, in seconds, after a scale in activity completes before
+     * another scale in activity can start. The cooldown period is used to block
+     * subsequent scale in requests until it has expired. You should scale in
+     * conservatively to protect your application's availability. However, if another
+     * alarm triggers a scale out policy during the cooldown period after a scale-in,
+     * application auto scaling scales out your scalable target immediately. </p>
+     */
+    inline int GetScaleInCooldown() const{ return m_scaleInCooldown; }
+
+    /**
+     * <p>The amount of time, in seconds, after a scale in activity completes before
+     * another scale in activity can start. The cooldown period is used to block
+     * subsequent scale in requests until it has expired. You should scale in
+     * conservatively to protect your application's availability. However, if another
+     * alarm triggers a scale out policy during the cooldown period after a scale-in,
+     * application auto scaling scales out your scalable target immediately. </p>
+     */
+    inline bool ScaleInCooldownHasBeenSet() const { return m_scaleInCooldownHasBeenSet; }
+
+    /**
+     * <p>The amount of time, in seconds, after a scale in activity completes before
+     * another scale in activity can start. The cooldown period is used to block
+     * subsequent scale in requests until it has expired. You should scale in
+     * conservatively to protect your application's availability. However, if another
+     * alarm triggers a scale out policy during the cooldown period after a scale-in,
+     * application auto scaling scales out your scalable target immediately. </p>
+     */
+    inline void SetScaleInCooldown(int value) { m_scaleInCooldownHasBeenSet = true; m_scaleInCooldown = value; }
+
+    /**
+     * <p>The amount of time, in seconds, after a scale in activity completes before
+     * another scale in activity can start. The cooldown period is used to block
+     * subsequent scale in requests until it has expired. You should scale in
+     * conservatively to protect your application's availability. However, if another
+     * alarm triggers a scale out policy during the cooldown period after a scale-in,
+     * application auto scaling scales out your scalable target immediately. </p>
+     */
+    inline AutoScalingTargetTrackingScalingPolicyConfigurationUpdate& WithScaleInCooldown(int value) { SetScaleInCooldown(value); return *this;}
+
+
+    /**
+     * <p>The amount of time, in seconds, after a scale out activity completes before
+     * another scale out activity can start. While the cooldown period is in effect,
+     * the capacity that has been added by the previous scale out event that initiated
+     * the cooldown is calculated as part of the desired capacity for the next scale
+     * out. You should continuously (but not excessively) scale out.</p>
+     */
+    inline int GetScaleOutCooldown() const{ return m_scaleOutCooldown; }
+
+    /**
+     * <p>The amount of time, in seconds, after a scale out activity completes before
+     * another scale out activity can start. While the cooldown period is in effect,
+     * the capacity that has been added by the previous scale out event that initiated
+     * the cooldown is calculated as part of the desired capacity for the next scale
+     * out. You should continuously (but not excessively) scale out.</p>
+     */
+    inline bool ScaleOutCooldownHasBeenSet() const { return m_scaleOutCooldownHasBeenSet; }
+
+    /**
+     * <p>The amount of time, in seconds, after a scale out activity completes before
+     * another scale out activity can start. While the cooldown period is in effect,
+     * the capacity that has been added by the previous scale out event that initiated
+     * the cooldown is calculated as part of the desired capacity for the next scale
+     * out. You should continuously (but not excessively) scale out.</p>
+     */
+    inline void SetScaleOutCooldown(int value) { m_scaleOutCooldownHasBeenSet = true; m_scaleOutCooldown = value; }
+
+    /**
+     * <p>The amount of time, in seconds, after a scale out activity completes before
+     * another scale out activity can start. While the cooldown period is in effect,
+     * the capacity that has been added by the previous scale out event that initiated
+     * the cooldown is calculated as part of the desired capacity for the next scale
+     * out. You should continuously (but not excessively) scale out.</p>
+     */
+    inline AutoScalingTargetTrackingScalingPolicyConfigurationUpdate& WithScaleOutCooldown(int value) { SetScaleOutCooldown(value); return *this;}
+
+
+    /**
+     * <p>The target value for the metric. The range is 8.515920e-109 to 1.174271e+108
+     * (Base 10) or 2e-360 to 2e360 (Base 2).</p>
+     */
+    inline double GetTargetValue() const{ return m_targetValue; }
+
+    /**
+     * <p>The target value for the metric. The range is 8.515920e-109 to 1.174271e+108
+     * (Base 10) or 2e-360 to 2e360 (Base 2).</p>
+     */
+    inline bool TargetValueHasBeenSet() const { return m_targetValueHasBeenSet; }
+
+    /**
+     * <p>The target value for the metric. The range is 8.515920e-109 to 1.174271e+108
+     * (Base 10) or 2e-360 to 2e360 (Base 2).</p>
+     */
+    inline void SetTargetValue(double value) { m_targetValueHasBeenSet = true; m_targetValue = value; }
+
+    /**
+     * <p>The target value for the metric. The range is 8.515920e-109 to 1.174271e+108
+     * (Base 10) or 2e-360 to 2e360 (Base 2).</p>
+     */
+    inline AutoScalingTargetTrackingScalingPolicyConfigurationUpdate& WithTargetValue(double value) { SetTargetValue(value); return *this;}
+
+  private:
+
+    bool m_disableScaleIn;
+    bool m_disableScaleInHasBeenSet;
+
+    int m_scaleInCooldown;
+    bool m_scaleInCooldownHasBeenSet;
+
+    int m_scaleOutCooldown;
+    bool m_scaleOutCooldownHasBeenSet;
+
+    double m_targetValue;
+    bool m_targetValueHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/BackupDescription.h

@@ -0,0 +1,155 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/model/BackupDetails.h>
+#include <aws/dynamodb/model/SourceTableDetails.h>
+#include <aws/dynamodb/model/SourceTableFeatureDetails.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Contains the description of the backup created for the table.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/BackupDescription">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API BackupDescription
+  {
+  public:
+    BackupDescription();
+    BackupDescription(Aws::Utils::Json::JsonView jsonValue);
+    BackupDescription& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Contains the details of the backup created for the table. </p>
+     */
+    inline const BackupDetails& GetBackupDetails() const{ return m_backupDetails; }
+
+    /**
+     * <p>Contains the details of the backup created for the table. </p>
+     */
+    inline bool BackupDetailsHasBeenSet() const { return m_backupDetailsHasBeenSet; }
+
+    /**
+     * <p>Contains the details of the backup created for the table. </p>
+     */
+    inline void SetBackupDetails(const BackupDetails& value) { m_backupDetailsHasBeenSet = true; m_backupDetails = value; }
+
+    /**
+     * <p>Contains the details of the backup created for the table. </p>
+     */
+    inline void SetBackupDetails(BackupDetails&& value) { m_backupDetailsHasBeenSet = true; m_backupDetails = std::move(value); }
+
+    /**
+     * <p>Contains the details of the backup created for the table. </p>
+     */
+    inline BackupDescription& WithBackupDetails(const BackupDetails& value) { SetBackupDetails(value); return *this;}
+
+    /**
+     * <p>Contains the details of the backup created for the table. </p>
+     */
+    inline BackupDescription& WithBackupDetails(BackupDetails&& value) { SetBackupDetails(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Contains the details of the table when the backup was created. </p>
+     */
+    inline const SourceTableDetails& GetSourceTableDetails() const{ return m_sourceTableDetails; }
+
+    /**
+     * <p>Contains the details of the table when the backup was created. </p>
+     */
+    inline bool SourceTableDetailsHasBeenSet() const { return m_sourceTableDetailsHasBeenSet; }
+
+    /**
+     * <p>Contains the details of the table when the backup was created. </p>
+     */
+    inline void SetSourceTableDetails(const SourceTableDetails& value) { m_sourceTableDetailsHasBeenSet = true; m_sourceTableDetails = value; }
+
+    /**
+     * <p>Contains the details of the table when the backup was created. </p>
+     */
+    inline void SetSourceTableDetails(SourceTableDetails&& value) { m_sourceTableDetailsHasBeenSet = true; m_sourceTableDetails = std::move(value); }
+
+    /**
+     * <p>Contains the details of the table when the backup was created. </p>
+     */
+    inline BackupDescription& WithSourceTableDetails(const SourceTableDetails& value) { SetSourceTableDetails(value); return *this;}
+
+    /**
+     * <p>Contains the details of the table when the backup was created. </p>
+     */
+    inline BackupDescription& WithSourceTableDetails(SourceTableDetails&& value) { SetSourceTableDetails(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Contains the details of the features enabled on the table when the backup was
+     * created. For example, LSIs, GSIs, streams, TTL.</p>
+     */
+    inline const SourceTableFeatureDetails& GetSourceTableFeatureDetails() const{ return m_sourceTableFeatureDetails; }
+
+    /**
+     * <p>Contains the details of the features enabled on the table when the backup was
+     * created. For example, LSIs, GSIs, streams, TTL.</p>
+     */
+    inline bool SourceTableFeatureDetailsHasBeenSet() const { return m_sourceTableFeatureDetailsHasBeenSet; }
+
+    /**
+     * <p>Contains the details of the features enabled on the table when the backup was
+     * created. For example, LSIs, GSIs, streams, TTL.</p>
+     */
+    inline void SetSourceTableFeatureDetails(const SourceTableFeatureDetails& value) { m_sourceTableFeatureDetailsHasBeenSet = true; m_sourceTableFeatureDetails = value; }
+
+    /**
+     * <p>Contains the details of the features enabled on the table when the backup was
+     * created. For example, LSIs, GSIs, streams, TTL.</p>
+     */
+    inline void SetSourceTableFeatureDetails(SourceTableFeatureDetails&& value) { m_sourceTableFeatureDetailsHasBeenSet = true; m_sourceTableFeatureDetails = std::move(value); }
+
+    /**
+     * <p>Contains the details of the features enabled on the table when the backup was
+     * created. For example, LSIs, GSIs, streams, TTL.</p>
+     */
+    inline BackupDescription& WithSourceTableFeatureDetails(const SourceTableFeatureDetails& value) { SetSourceTableFeatureDetails(value); return *this;}
+
+    /**
+     * <p>Contains the details of the features enabled on the table when the backup was
+     * created. For example, LSIs, GSIs, streams, TTL.</p>
+     */
+    inline BackupDescription& WithSourceTableFeatureDetails(SourceTableFeatureDetails&& value) { SetSourceTableFeatureDetails(std::move(value)); return *this;}
+
+  private:
+
+    BackupDetails m_backupDetails;
+    bool m_backupDetailsHasBeenSet;
+
+    SourceTableDetails m_sourceTableDetails;
+    bool m_sourceTableDetailsHasBeenSet;
+
+    SourceTableFeatureDetails m_sourceTableFeatureDetails;
+    bool m_sourceTableFeatureDetailsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/BackupDetails.h

@@ -0,0 +1,356 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/dynamodb/model/BackupStatus.h>
+#include <aws/dynamodb/model/BackupType.h>
+#include <aws/core/utils/DateTime.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Contains the details of the backup created for the table.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/BackupDetails">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API BackupDetails
+  {
+  public:
+    BackupDetails();
+    BackupDetails(Aws::Utils::Json::JsonView jsonValue);
+    BackupDetails& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>ARN associated with the backup.</p>
+     */
+    inline const Aws::String& GetBackupArn() const{ return m_backupArn; }
+
+    /**
+     * <p>ARN associated with the backup.</p>
+     */
+    inline bool BackupArnHasBeenSet() const { return m_backupArnHasBeenSet; }
+
+    /**
+     * <p>ARN associated with the backup.</p>
+     */
+    inline void SetBackupArn(const Aws::String& value) { m_backupArnHasBeenSet = true; m_backupArn = value; }
+
+    /**
+     * <p>ARN associated with the backup.</p>
+     */
+    inline void SetBackupArn(Aws::String&& value) { m_backupArnHasBeenSet = true; m_backupArn = std::move(value); }
+
+    /**
+     * <p>ARN associated with the backup.</p>
+     */
+    inline void SetBackupArn(const char* value) { m_backupArnHasBeenSet = true; m_backupArn.assign(value); }
+
+    /**
+     * <p>ARN associated with the backup.</p>
+     */
+    inline BackupDetails& WithBackupArn(const Aws::String& value) { SetBackupArn(value); return *this;}
+
+    /**
+     * <p>ARN associated with the backup.</p>
+     */
+    inline BackupDetails& WithBackupArn(Aws::String&& value) { SetBackupArn(std::move(value)); return *this;}
+
+    /**
+     * <p>ARN associated with the backup.</p>
+     */
+    inline BackupDetails& WithBackupArn(const char* value) { SetBackupArn(value); return *this;}
+
+
+    /**
+     * <p>Name of the requested backup.</p>
+     */
+    inline const Aws::String& GetBackupName() const{ return m_backupName; }
+
+    /**
+     * <p>Name of the requested backup.</p>
+     */
+    inline bool BackupNameHasBeenSet() const { return m_backupNameHasBeenSet; }
+
+    /**
+     * <p>Name of the requested backup.</p>
+     */
+    inline void SetBackupName(const Aws::String& value) { m_backupNameHasBeenSet = true; m_backupName = value; }
+
+    /**
+     * <p>Name of the requested backup.</p>
+     */
+    inline void SetBackupName(Aws::String&& value) { m_backupNameHasBeenSet = true; m_backupName = std::move(value); }
+
+    /**
+     * <p>Name of the requested backup.</p>
+     */
+    inline void SetBackupName(const char* value) { m_backupNameHasBeenSet = true; m_backupName.assign(value); }
+
+    /**
+     * <p>Name of the requested backup.</p>
+     */
+    inline BackupDetails& WithBackupName(const Aws::String& value) { SetBackupName(value); return *this;}
+
+    /**
+     * <p>Name of the requested backup.</p>
+     */
+    inline BackupDetails& WithBackupName(Aws::String&& value) { SetBackupName(std::move(value)); return *this;}
+
+    /**
+     * <p>Name of the requested backup.</p>
+     */
+    inline BackupDetails& WithBackupName(const char* value) { SetBackupName(value); return *this;}
+
+
+    /**
+     * <p>Size of the backup in bytes.</p>
+     */
+    inline long long GetBackupSizeBytes() const{ return m_backupSizeBytes; }
+
+    /**
+     * <p>Size of the backup in bytes.</p>
+     */
+    inline bool BackupSizeBytesHasBeenSet() const { return m_backupSizeBytesHasBeenSet; }
+
+    /**
+     * <p>Size of the backup in bytes.</p>
+     */
+    inline void SetBackupSizeBytes(long long value) { m_backupSizeBytesHasBeenSet = true; m_backupSizeBytes = value; }
+
+    /**
+     * <p>Size of the backup in bytes.</p>
+     */
+    inline BackupDetails& WithBackupSizeBytes(long long value) { SetBackupSizeBytes(value); return *this;}
+
+
+    /**
+     * <p>Backup can be in one of the following states: CREATING, ACTIVE, DELETED. </p>
+     */
+    inline const BackupStatus& GetBackupStatus() const{ return m_backupStatus; }
+
+    /**
+     * <p>Backup can be in one of the following states: CREATING, ACTIVE, DELETED. </p>
+     */
+    inline bool BackupStatusHasBeenSet() const { return m_backupStatusHasBeenSet; }
+
+    /**
+     * <p>Backup can be in one of the following states: CREATING, ACTIVE, DELETED. </p>
+     */
+    inline void SetBackupStatus(const BackupStatus& value) { m_backupStatusHasBeenSet = true; m_backupStatus = value; }
+
+    /**
+     * <p>Backup can be in one of the following states: CREATING, ACTIVE, DELETED. </p>
+     */
+    inline void SetBackupStatus(BackupStatus&& value) { m_backupStatusHasBeenSet = true; m_backupStatus = std::move(value); }
+
+    /**
+     * <p>Backup can be in one of the following states: CREATING, ACTIVE, DELETED. </p>
+     */
+    inline BackupDetails& WithBackupStatus(const BackupStatus& value) { SetBackupStatus(value); return *this;}
+
+    /**
+     * <p>Backup can be in one of the following states: CREATING, ACTIVE, DELETED. </p>
+     */
+    inline BackupDetails& WithBackupStatus(BackupStatus&& value) { SetBackupStatus(std::move(value)); return *this;}
+
+
+    /**
+     * <p>BackupType:</p> <ul> <li> <p> <code>USER</code> - You create and manage these
+     * using the on-demand backup feature.</p> </li> <li> <p> <code>SYSTEM</code> - If
+     * you delete a table with point-in-time recovery enabled, a <code>SYSTEM</code>
+     * backup is automatically created and is retained for 35 days (at no additional
+     * cost). System backups allow you to restore the deleted table to the state it was
+     * in just before the point of deletion. </p> </li> <li> <p>
+     * <code>AWS_BACKUP</code> - On-demand backup created by you from AWS Backup
+     * service.</p> </li> </ul>
+     */
+    inline const BackupType& GetBackupType() const{ return m_backupType; }
+
+    /**
+     * <p>BackupType:</p> <ul> <li> <p> <code>USER</code> - You create and manage these
+     * using the on-demand backup feature.</p> </li> <li> <p> <code>SYSTEM</code> - If
+     * you delete a table with point-in-time recovery enabled, a <code>SYSTEM</code>
+     * backup is automatically created and is retained for 35 days (at no additional
+     * cost). System backups allow you to restore the deleted table to the state it was
+     * in just before the point of deletion. </p> </li> <li> <p>
+     * <code>AWS_BACKUP</code> - On-demand backup created by you from AWS Backup
+     * service.</p> </li> </ul>
+     */
+    inline bool BackupTypeHasBeenSet() const { return m_backupTypeHasBeenSet; }
+
+    /**
+     * <p>BackupType:</p> <ul> <li> <p> <code>USER</code> - You create and manage these
+     * using the on-demand backup feature.</p> </li> <li> <p> <code>SYSTEM</code> - If
+     * you delete a table with point-in-time recovery enabled, a <code>SYSTEM</code>
+     * backup is automatically created and is retained for 35 days (at no additional
+     * cost). System backups allow you to restore the deleted table to the state it was
+     * in just before the point of deletion. </p> </li> <li> <p>
+     * <code>AWS_BACKUP</code> - On-demand backup created by you from AWS Backup
+     * service.</p> </li> </ul>
+     */
+    inline void SetBackupType(const BackupType& value) { m_backupTypeHasBeenSet = true; m_backupType = value; }
+
+    /**
+     * <p>BackupType:</p> <ul> <li> <p> <code>USER</code> - You create and manage these
+     * using the on-demand backup feature.</p> </li> <li> <p> <code>SYSTEM</code> - If
+     * you delete a table with point-in-time recovery enabled, a <code>SYSTEM</code>
+     * backup is automatically created and is retained for 35 days (at no additional
+     * cost). System backups allow you to restore the deleted table to the state it was
+     * in just before the point of deletion. </p> </li> <li> <p>
+     * <code>AWS_BACKUP</code> - On-demand backup created by you from AWS Backup
+     * service.</p> </li> </ul>
+     */
+    inline void SetBackupType(BackupType&& value) { m_backupTypeHasBeenSet = true; m_backupType = std::move(value); }
+
+    /**
+     * <p>BackupType:</p> <ul> <li> <p> <code>USER</code> - You create and manage these
+     * using the on-demand backup feature.</p> </li> <li> <p> <code>SYSTEM</code> - If
+     * you delete a table with point-in-time recovery enabled, a <code>SYSTEM</code>
+     * backup is automatically created and is retained for 35 days (at no additional
+     * cost). System backups allow you to restore the deleted table to the state it was
+     * in just before the point of deletion. </p> </li> <li> <p>
+     * <code>AWS_BACKUP</code> - On-demand backup created by you from AWS Backup
+     * service.</p> </li> </ul>
+     */
+    inline BackupDetails& WithBackupType(const BackupType& value) { SetBackupType(value); return *this;}
+
+    /**
+     * <p>BackupType:</p> <ul> <li> <p> <code>USER</code> - You create and manage these
+     * using the on-demand backup feature.</p> </li> <li> <p> <code>SYSTEM</code> - If
+     * you delete a table with point-in-time recovery enabled, a <code>SYSTEM</code>
+     * backup is automatically created and is retained for 35 days (at no additional
+     * cost). System backups allow you to restore the deleted table to the state it was
+     * in just before the point of deletion. </p> </li> <li> <p>
+     * <code>AWS_BACKUP</code> - On-demand backup created by you from AWS Backup
+     * service.</p> </li> </ul>
+     */
+    inline BackupDetails& WithBackupType(BackupType&& value) { SetBackupType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Time at which the backup was created. This is the request time of the backup.
+     * </p>
+     */
+    inline const Aws::Utils::DateTime& GetBackupCreationDateTime() const{ return m_backupCreationDateTime; }
+
+    /**
+     * <p>Time at which the backup was created. This is the request time of the backup.
+     * </p>
+     */
+    inline bool BackupCreationDateTimeHasBeenSet() const { return m_backupCreationDateTimeHasBeenSet; }
+
+    /**
+     * <p>Time at which the backup was created. This is the request time of the backup.
+     * </p>
+     */
+    inline void SetBackupCreationDateTime(const Aws::Utils::DateTime& value) { m_backupCreationDateTimeHasBeenSet = true; m_backupCreationDateTime = value; }
+
+    /**
+     * <p>Time at which the backup was created. This is the request time of the backup.
+     * </p>
+     */
+    inline void SetBackupCreationDateTime(Aws::Utils::DateTime&& value) { m_backupCreationDateTimeHasBeenSet = true; m_backupCreationDateTime = std::move(value); }
+
+    /**
+     * <p>Time at which the backup was created. This is the request time of the backup.
+     * </p>
+     */
+    inline BackupDetails& WithBackupCreationDateTime(const Aws::Utils::DateTime& value) { SetBackupCreationDateTime(value); return *this;}
+
+    /**
+     * <p>Time at which the backup was created. This is the request time of the backup.
+     * </p>
+     */
+    inline BackupDetails& WithBackupCreationDateTime(Aws::Utils::DateTime&& value) { SetBackupCreationDateTime(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Time at which the automatic on-demand backup created by DynamoDB will expire.
+     * This <code>SYSTEM</code> on-demand backup expires automatically 35 days after
+     * its creation.</p>
+     */
+    inline const Aws::Utils::DateTime& GetBackupExpiryDateTime() const{ return m_backupExpiryDateTime; }
+
+    /**
+     * <p>Time at which the automatic on-demand backup created by DynamoDB will expire.
+     * This <code>SYSTEM</code> on-demand backup expires automatically 35 days after
+     * its creation.</p>
+     */
+    inline bool BackupExpiryDateTimeHasBeenSet() const { return m_backupExpiryDateTimeHasBeenSet; }
+
+    /**
+     * <p>Time at which the automatic on-demand backup created by DynamoDB will expire.
+     * This <code>SYSTEM</code> on-demand backup expires automatically 35 days after
+     * its creation.</p>
+     */
+    inline void SetBackupExpiryDateTime(const Aws::Utils::DateTime& value) { m_backupExpiryDateTimeHasBeenSet = true; m_backupExpiryDateTime = value; }
+
+    /**
+     * <p>Time at which the automatic on-demand backup created by DynamoDB will expire.
+     * This <code>SYSTEM</code> on-demand backup expires automatically 35 days after
+     * its creation.</p>
+     */
+    inline void SetBackupExpiryDateTime(Aws::Utils::DateTime&& value) { m_backupExpiryDateTimeHasBeenSet = true; m_backupExpiryDateTime = std::move(value); }
+
+    /**
+     * <p>Time at which the automatic on-demand backup created by DynamoDB will expire.
+     * This <code>SYSTEM</code> on-demand backup expires automatically 35 days after
+     * its creation.</p>
+     */
+    inline BackupDetails& WithBackupExpiryDateTime(const Aws::Utils::DateTime& value) { SetBackupExpiryDateTime(value); return *this;}
+
+    /**
+     * <p>Time at which the automatic on-demand backup created by DynamoDB will expire.
+     * This <code>SYSTEM</code> on-demand backup expires automatically 35 days after
+     * its creation.</p>
+     */
+    inline BackupDetails& WithBackupExpiryDateTime(Aws::Utils::DateTime&& value) { SetBackupExpiryDateTime(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_backupArn;
+    bool m_backupArnHasBeenSet;
+
+    Aws::String m_backupName;
+    bool m_backupNameHasBeenSet;
+
+    long long m_backupSizeBytes;
+    bool m_backupSizeBytesHasBeenSet;
+
+    BackupStatus m_backupStatus;
+    bool m_backupStatusHasBeenSet;
+
+    BackupType m_backupType;
+    bool m_backupTypeHasBeenSet;
+
+    Aws::Utils::DateTime m_backupCreationDateTime;
+    bool m_backupCreationDateTimeHasBeenSet;
+
+    Aws::Utils::DateTime m_backupExpiryDateTime;
+    bool m_backupExpiryDateTimeHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/BackupStatus.h

@@ -0,0 +1,32 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+  enum class BackupStatus
+  {
+    NOT_SET,
+    CREATING,
+    DELETED,
+    AVAILABLE
+  };
+
+namespace BackupStatusMapper
+{
+AWS_DYNAMODB_API BackupStatus GetBackupStatusForName(const Aws::String& name);
+
+AWS_DYNAMODB_API Aws::String GetNameForBackupStatus(BackupStatus value);
+} // namespace BackupStatusMapper
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/BackupSummary.h

@@ -0,0 +1,481 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/DateTime.h>
+#include <aws/dynamodb/model/BackupStatus.h>
+#include <aws/dynamodb/model/BackupType.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Contains details for the backup.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/BackupSummary">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API BackupSummary
+  {
+  public:
+    BackupSummary();
+    BackupSummary(Aws::Utils::Json::JsonView jsonValue);
+    BackupSummary& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Name of the table.</p>
+     */
+    inline const Aws::String& GetTableName() const{ return m_tableName; }
+
+    /**
+     * <p>Name of the table.</p>
+     */
+    inline bool TableNameHasBeenSet() const { return m_tableNameHasBeenSet; }
+
+    /**
+     * <p>Name of the table.</p>
+     */
+    inline void SetTableName(const Aws::String& value) { m_tableNameHasBeenSet = true; m_tableName = value; }
+
+    /**
+     * <p>Name of the table.</p>
+     */
+    inline void SetTableName(Aws::String&& value) { m_tableNameHasBeenSet = true; m_tableName = std::move(value); }
+
+    /**
+     * <p>Name of the table.</p>
+     */
+    inline void SetTableName(const char* value) { m_tableNameHasBeenSet = true; m_tableName.assign(value); }
+
+    /**
+     * <p>Name of the table.</p>
+     */
+    inline BackupSummary& WithTableName(const Aws::String& value) { SetTableName(value); return *this;}
+
+    /**
+     * <p>Name of the table.</p>
+     */
+    inline BackupSummary& WithTableName(Aws::String&& value) { SetTableName(std::move(value)); return *this;}
+
+    /**
+     * <p>Name of the table.</p>
+     */
+    inline BackupSummary& WithTableName(const char* value) { SetTableName(value); return *this;}
+
+
+    /**
+     * <p>Unique identifier for the table.</p>
+     */
+    inline const Aws::String& GetTableId() const{ return m_tableId; }
+
+    /**
+     * <p>Unique identifier for the table.</p>
+     */
+    inline bool TableIdHasBeenSet() const { return m_tableIdHasBeenSet; }
+
+    /**
+     * <p>Unique identifier for the table.</p>
+     */
+    inline void SetTableId(const Aws::String& value) { m_tableIdHasBeenSet = true; m_tableId = value; }
+
+    /**
+     * <p>Unique identifier for the table.</p>
+     */
+    inline void SetTableId(Aws::String&& value) { m_tableIdHasBeenSet = true; m_tableId = std::move(value); }
+
+    /**
+     * <p>Unique identifier for the table.</p>
+     */
+    inline void SetTableId(const char* value) { m_tableIdHasBeenSet = true; m_tableId.assign(value); }
+
+    /**
+     * <p>Unique identifier for the table.</p>
+     */
+    inline BackupSummary& WithTableId(const Aws::String& value) { SetTableId(value); return *this;}
+
+    /**
+     * <p>Unique identifier for the table.</p>
+     */
+    inline BackupSummary& WithTableId(Aws::String&& value) { SetTableId(std::move(value)); return *this;}
+
+    /**
+     * <p>Unique identifier for the table.</p>
+     */
+    inline BackupSummary& WithTableId(const char* value) { SetTableId(value); return *this;}
+
+
+    /**
+     * <p>ARN associated with the table.</p>
+     */
+    inline const Aws::String& GetTableArn() const{ return m_tableArn; }
+
+    /**
+     * <p>ARN associated with the table.</p>
+     */
+    inline bool TableArnHasBeenSet() const { return m_tableArnHasBeenSet; }
+
+    /**
+     * <p>ARN associated with the table.</p>
+     */
+    inline void SetTableArn(const Aws::String& value) { m_tableArnHasBeenSet = true; m_tableArn = value; }
+
+    /**
+     * <p>ARN associated with the table.</p>
+     */
+    inline void SetTableArn(Aws::String&& value) { m_tableArnHasBeenSet = true; m_tableArn = std::move(value); }
+
+    /**
+     * <p>ARN associated with the table.</p>
+     */
+    inline void SetTableArn(const char* value) { m_tableArnHasBeenSet = true; m_tableArn.assign(value); }
+
+    /**
+     * <p>ARN associated with the table.</p>
+     */
+    inline BackupSummary& WithTableArn(const Aws::String& value) { SetTableArn(value); return *this;}
+
+    /**
+     * <p>ARN associated with the table.</p>
+     */
+    inline BackupSummary& WithTableArn(Aws::String&& value) { SetTableArn(std::move(value)); return *this;}
+
+    /**
+     * <p>ARN associated with the table.</p>
+     */
+    inline BackupSummary& WithTableArn(const char* value) { SetTableArn(value); return *this;}
+
+
+    /**
+     * <p>ARN associated with the backup.</p>
+     */
+    inline const Aws::String& GetBackupArn() const{ return m_backupArn; }
+
+    /**
+     * <p>ARN associated with the backup.</p>
+     */
+    inline bool BackupArnHasBeenSet() const { return m_backupArnHasBeenSet; }
+
+    /**
+     * <p>ARN associated with the backup.</p>
+     */
+    inline void SetBackupArn(const Aws::String& value) { m_backupArnHasBeenSet = true; m_backupArn = value; }
+
+    /**
+     * <p>ARN associated with the backup.</p>
+     */
+    inline void SetBackupArn(Aws::String&& value) { m_backupArnHasBeenSet = true; m_backupArn = std::move(value); }
+
+    /**
+     * <p>ARN associated with the backup.</p>
+     */
+    inline void SetBackupArn(const char* value) { m_backupArnHasBeenSet = true; m_backupArn.assign(value); }
+
+    /**
+     * <p>ARN associated with the backup.</p>
+     */
+    inline BackupSummary& WithBackupArn(const Aws::String& value) { SetBackupArn(value); return *this;}
+
+    /**
+     * <p>ARN associated with the backup.</p>
+     */
+    inline BackupSummary& WithBackupArn(Aws::String&& value) { SetBackupArn(std::move(value)); return *this;}
+
+    /**
+     * <p>ARN associated with the backup.</p>
+     */
+    inline BackupSummary& WithBackupArn(const char* value) { SetBackupArn(value); return *this;}
+
+
+    /**
+     * <p>Name of the specified backup.</p>
+     */
+    inline const Aws::String& GetBackupName() const{ return m_backupName; }
+
+    /**
+     * <p>Name of the specified backup.</p>
+     */
+    inline bool BackupNameHasBeenSet() const { return m_backupNameHasBeenSet; }
+
+    /**
+     * <p>Name of the specified backup.</p>
+     */
+    inline void SetBackupName(const Aws::String& value) { m_backupNameHasBeenSet = true; m_backupName = value; }
+
+    /**
+     * <p>Name of the specified backup.</p>
+     */
+    inline void SetBackupName(Aws::String&& value) { m_backupNameHasBeenSet = true; m_backupName = std::move(value); }
+
+    /**
+     * <p>Name of the specified backup.</p>
+     */
+    inline void SetBackupName(const char* value) { m_backupNameHasBeenSet = true; m_backupName.assign(value); }
+
+    /**
+     * <p>Name of the specified backup.</p>
+     */
+    inline BackupSummary& WithBackupName(const Aws::String& value) { SetBackupName(value); return *this;}
+
+    /**
+     * <p>Name of the specified backup.</p>
+     */
+    inline BackupSummary& WithBackupName(Aws::String&& value) { SetBackupName(std::move(value)); return *this;}
+
+    /**
+     * <p>Name of the specified backup.</p>
+     */
+    inline BackupSummary& WithBackupName(const char* value) { SetBackupName(value); return *this;}
+
+
+    /**
+     * <p>Time at which the backup was created.</p>
+     */
+    inline const Aws::Utils::DateTime& GetBackupCreationDateTime() const{ return m_backupCreationDateTime; }
+
+    /**
+     * <p>Time at which the backup was created.</p>
+     */
+    inline bool BackupCreationDateTimeHasBeenSet() const { return m_backupCreationDateTimeHasBeenSet; }
+
+    /**
+     * <p>Time at which the backup was created.</p>
+     */
+    inline void SetBackupCreationDateTime(const Aws::Utils::DateTime& value) { m_backupCreationDateTimeHasBeenSet = true; m_backupCreationDateTime = value; }
+
+    /**
+     * <p>Time at which the backup was created.</p>
+     */
+    inline void SetBackupCreationDateTime(Aws::Utils::DateTime&& value) { m_backupCreationDateTimeHasBeenSet = true; m_backupCreationDateTime = std::move(value); }
+
+    /**
+     * <p>Time at which the backup was created.</p>
+     */
+    inline BackupSummary& WithBackupCreationDateTime(const Aws::Utils::DateTime& value) { SetBackupCreationDateTime(value); return *this;}
+
+    /**
+     * <p>Time at which the backup was created.</p>
+     */
+    inline BackupSummary& WithBackupCreationDateTime(Aws::Utils::DateTime&& value) { SetBackupCreationDateTime(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Time at which the automatic on-demand backup created by DynamoDB will expire.
+     * This <code>SYSTEM</code> on-demand backup expires automatically 35 days after
+     * its creation.</p>
+     */
+    inline const Aws::Utils::DateTime& GetBackupExpiryDateTime() const{ return m_backupExpiryDateTime; }
+
+    /**
+     * <p>Time at which the automatic on-demand backup created by DynamoDB will expire.
+     * This <code>SYSTEM</code> on-demand backup expires automatically 35 days after
+     * its creation.</p>
+     */
+    inline bool BackupExpiryDateTimeHasBeenSet() const { return m_backupExpiryDateTimeHasBeenSet; }
+
+    /**
+     * <p>Time at which the automatic on-demand backup created by DynamoDB will expire.
+     * This <code>SYSTEM</code> on-demand backup expires automatically 35 days after
+     * its creation.</p>
+     */
+    inline void SetBackupExpiryDateTime(const Aws::Utils::DateTime& value) { m_backupExpiryDateTimeHasBeenSet = true; m_backupExpiryDateTime = value; }
+
+    /**
+     * <p>Time at which the automatic on-demand backup created by DynamoDB will expire.
+     * This <code>SYSTEM</code> on-demand backup expires automatically 35 days after
+     * its creation.</p>
+     */
+    inline void SetBackupExpiryDateTime(Aws::Utils::DateTime&& value) { m_backupExpiryDateTimeHasBeenSet = true; m_backupExpiryDateTime = std::move(value); }
+
+    /**
+     * <p>Time at which the automatic on-demand backup created by DynamoDB will expire.
+     * This <code>SYSTEM</code> on-demand backup expires automatically 35 days after
+     * its creation.</p>
+     */
+    inline BackupSummary& WithBackupExpiryDateTime(const Aws::Utils::DateTime& value) { SetBackupExpiryDateTime(value); return *this;}
+
+    /**
+     * <p>Time at which the automatic on-demand backup created by DynamoDB will expire.
+     * This <code>SYSTEM</code> on-demand backup expires automatically 35 days after
+     * its creation.</p>
+     */
+    inline BackupSummary& WithBackupExpiryDateTime(Aws::Utils::DateTime&& value) { SetBackupExpiryDateTime(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Backup can be in one of the following states: CREATING, ACTIVE, DELETED.</p>
+     */
+    inline const BackupStatus& GetBackupStatus() const{ return m_backupStatus; }
+
+    /**
+     * <p>Backup can be in one of the following states: CREATING, ACTIVE, DELETED.</p>
+     */
+    inline bool BackupStatusHasBeenSet() const { return m_backupStatusHasBeenSet; }
+
+    /**
+     * <p>Backup can be in one of the following states: CREATING, ACTIVE, DELETED.</p>
+     */
+    inline void SetBackupStatus(const BackupStatus& value) { m_backupStatusHasBeenSet = true; m_backupStatus = value; }
+
+    /**
+     * <p>Backup can be in one of the following states: CREATING, ACTIVE, DELETED.</p>
+     */
+    inline void SetBackupStatus(BackupStatus&& value) { m_backupStatusHasBeenSet = true; m_backupStatus = std::move(value); }
+
+    /**
+     * <p>Backup can be in one of the following states: CREATING, ACTIVE, DELETED.</p>
+     */
+    inline BackupSummary& WithBackupStatus(const BackupStatus& value) { SetBackupStatus(value); return *this;}
+
+    /**
+     * <p>Backup can be in one of the following states: CREATING, ACTIVE, DELETED.</p>
+     */
+    inline BackupSummary& WithBackupStatus(BackupStatus&& value) { SetBackupStatus(std::move(value)); return *this;}
+
+
+    /**
+     * <p>BackupType:</p> <ul> <li> <p> <code>USER</code> - You create and manage these
+     * using the on-demand backup feature.</p> </li> <li> <p> <code>SYSTEM</code> - If
+     * you delete a table with point-in-time recovery enabled, a <code>SYSTEM</code>
+     * backup is automatically created and is retained for 35 days (at no additional
+     * cost). System backups allow you to restore the deleted table to the state it was
+     * in just before the point of deletion. </p> </li> <li> <p>
+     * <code>AWS_BACKUP</code> - On-demand backup created by you from AWS Backup
+     * service.</p> </li> </ul>
+     */
+    inline const BackupType& GetBackupType() const{ return m_backupType; }
+
+    /**
+     * <p>BackupType:</p> <ul> <li> <p> <code>USER</code> - You create and manage these
+     * using the on-demand backup feature.</p> </li> <li> <p> <code>SYSTEM</code> - If
+     * you delete a table with point-in-time recovery enabled, a <code>SYSTEM</code>
+     * backup is automatically created and is retained for 35 days (at no additional
+     * cost). System backups allow you to restore the deleted table to the state it was
+     * in just before the point of deletion. </p> </li> <li> <p>
+     * <code>AWS_BACKUP</code> - On-demand backup created by you from AWS Backup
+     * service.</p> </li> </ul>
+     */
+    inline bool BackupTypeHasBeenSet() const { return m_backupTypeHasBeenSet; }
+
+    /**
+     * <p>BackupType:</p> <ul> <li> <p> <code>USER</code> - You create and manage these
+     * using the on-demand backup feature.</p> </li> <li> <p> <code>SYSTEM</code> - If
+     * you delete a table with point-in-time recovery enabled, a <code>SYSTEM</code>
+     * backup is automatically created and is retained for 35 days (at no additional
+     * cost). System backups allow you to restore the deleted table to the state it was
+     * in just before the point of deletion. </p> </li> <li> <p>
+     * <code>AWS_BACKUP</code> - On-demand backup created by you from AWS Backup
+     * service.</p> </li> </ul>
+     */
+    inline void SetBackupType(const BackupType& value) { m_backupTypeHasBeenSet = true; m_backupType = value; }
+
+    /**
+     * <p>BackupType:</p> <ul> <li> <p> <code>USER</code> - You create and manage these
+     * using the on-demand backup feature.</p> </li> <li> <p> <code>SYSTEM</code> - If
+     * you delete a table with point-in-time recovery enabled, a <code>SYSTEM</code>
+     * backup is automatically created and is retained for 35 days (at no additional
+     * cost). System backups allow you to restore the deleted table to the state it was
+     * in just before the point of deletion. </p> </li> <li> <p>
+     * <code>AWS_BACKUP</code> - On-demand backup created by you from AWS Backup
+     * service.</p> </li> </ul>
+     */
+    inline void SetBackupType(BackupType&& value) { m_backupTypeHasBeenSet = true; m_backupType = std::move(value); }
+
+    /**
+     * <p>BackupType:</p> <ul> <li> <p> <code>USER</code> - You create and manage these
+     * using the on-demand backup feature.</p> </li> <li> <p> <code>SYSTEM</code> - If
+     * you delete a table with point-in-time recovery enabled, a <code>SYSTEM</code>
+     * backup is automatically created and is retained for 35 days (at no additional
+     * cost). System backups allow you to restore the deleted table to the state it was
+     * in just before the point of deletion. </p> </li> <li> <p>
+     * <code>AWS_BACKUP</code> - On-demand backup created by you from AWS Backup
+     * service.</p> </li> </ul>
+     */
+    inline BackupSummary& WithBackupType(const BackupType& value) { SetBackupType(value); return *this;}
+
+    /**
+     * <p>BackupType:</p> <ul> <li> <p> <code>USER</code> - You create and manage these
+     * using the on-demand backup feature.</p> </li> <li> <p> <code>SYSTEM</code> - If
+     * you delete a table with point-in-time recovery enabled, a <code>SYSTEM</code>
+     * backup is automatically created and is retained for 35 days (at no additional
+     * cost). System backups allow you to restore the deleted table to the state it was
+     * in just before the point of deletion. </p> </li> <li> <p>
+     * <code>AWS_BACKUP</code> - On-demand backup created by you from AWS Backup
+     * service.</p> </li> </ul>
+     */
+    inline BackupSummary& WithBackupType(BackupType&& value) { SetBackupType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Size of the backup in bytes.</p>
+     */
+    inline long long GetBackupSizeBytes() const{ return m_backupSizeBytes; }
+
+    /**
+     * <p>Size of the backup in bytes.</p>
+     */
+    inline bool BackupSizeBytesHasBeenSet() const { return m_backupSizeBytesHasBeenSet; }
+
+    /**
+     * <p>Size of the backup in bytes.</p>
+     */
+    inline void SetBackupSizeBytes(long long value) { m_backupSizeBytesHasBeenSet = true; m_backupSizeBytes = value; }
+
+    /**
+     * <p>Size of the backup in bytes.</p>
+     */
+    inline BackupSummary& WithBackupSizeBytes(long long value) { SetBackupSizeBytes(value); return *this;}
+
+  private:
+
+    Aws::String m_tableName;
+    bool m_tableNameHasBeenSet;
+
+    Aws::String m_tableId;
+    bool m_tableIdHasBeenSet;
+
+    Aws::String m_tableArn;
+    bool m_tableArnHasBeenSet;
+
+    Aws::String m_backupArn;
+    bool m_backupArnHasBeenSet;
+
+    Aws::String m_backupName;
+    bool m_backupNameHasBeenSet;
+
+    Aws::Utils::DateTime m_backupCreationDateTime;
+    bool m_backupCreationDateTimeHasBeenSet;
+
+    Aws::Utils::DateTime m_backupExpiryDateTime;
+    bool m_backupExpiryDateTimeHasBeenSet;
+
+    BackupStatus m_backupStatus;
+    bool m_backupStatusHasBeenSet;
+
+    BackupType m_backupType;
+    bool m_backupTypeHasBeenSet;
+
+    long long m_backupSizeBytes;
+    bool m_backupSizeBytesHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/BackupType.h

@@ -0,0 +1,32 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+  enum class BackupType
+  {
+    NOT_SET,
+    USER,
+    SYSTEM,
+    AWS_BACKUP
+  };
+
+namespace BackupTypeMapper
+{
+AWS_DYNAMODB_API BackupType GetBackupTypeForName(const Aws::String& name);
+
+AWS_DYNAMODB_API Aws::String GetNameForBackupType(BackupType value);
+} // namespace BackupTypeMapper
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/BackupTypeFilter.h

@@ -0,0 +1,33 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+  enum class BackupTypeFilter
+  {
+    NOT_SET,
+    USER,
+    SYSTEM,
+    AWS_BACKUP,
+    ALL
+  };
+
+namespace BackupTypeFilterMapper
+{
+AWS_DYNAMODB_API BackupTypeFilter GetBackupTypeFilterForName(const Aws::String& name);
+
+AWS_DYNAMODB_API Aws::String GetNameForBackupTypeFilter(BackupTypeFilter value);
+} // namespace BackupTypeFilterMapper
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/BatchGetItemRequest.h

@@ -0,0 +1,686 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/DynamoDBRequest.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <aws/dynamodb/model/ReturnConsumedCapacity.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/dynamodb/model/KeysAndAttributes.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents the input of a <code>BatchGetItem</code> operation.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/BatchGetItemInput">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API BatchGetItemRequest : public DynamoDBRequest
+  {
+  public:
+    BatchGetItemRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "BatchGetItem"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>A map of one or more table names and, for each table, a map that describes
+     * one or more items to retrieve from that table. Each table name can be used only
+     * once per <code>BatchGetItem</code> request.</p> <p>Each element in the map of
+     * items to retrieve consists of the following:</p> <ul> <li> <p>
+     * <code>ConsistentRead</code> - If <code>true</code>, a strongly consistent read
+     * is used; if <code>false</code> (the default), an eventually consistent read is
+     * used.</p> </li> <li> <p> <code>ExpressionAttributeNames</code> - One or more
+     * substitution tokens for attribute names in the <code>ProjectionExpression</code>
+     * parameter. The following are some use cases for using
+     * <code>ExpressionAttributeNames</code>:</p> <ul> <li> <p>To access an attribute
+     * whose name conflicts with a DynamoDB reserved word.</p> </li> <li> <p>To create
+     * a placeholder for repeating occurrences of an attribute name in an
+     * expression.</p> </li> <li> <p>To prevent special characters in an attribute name
+     * from being misinterpreted in an expression.</p> </li> </ul> <p>Use the <b>#</b>
+     * character in an expression to dereference an attribute name. For example,
+     * consider the following attribute name:</p> <ul> <li> <p> <code>Percentile</code>
+     * </p> </li> </ul> <p>The name of this attribute conflicts with a reserved word,
+     * so it cannot be used directly in an expression. (For the complete list of
+     * reserved words, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved
+     * Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this,
+     * you could specify the following for <code>ExpressionAttributeNames</code>:</p>
+     * <ul> <li> <p> <code>{"#P":"Percentile"}</code> </p> </li> </ul> <p>You could
+     * then use this substitution in an expression, as in this example:</p> <ul> <li>
+     * <p> <code>#P = :val</code> </p> </li> </ul>  <p>Tokens that begin with the
+     * <b>:</b> character are <i>expression attribute values</i>, which are
+     * placeholders for the actual value at runtime.</p>  <p>For more
+     * information about expression attribute names, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Accessing
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> </li>
+     * <li> <p> <code>Keys</code> - An array of primary key attribute values that
+     * define specific items in the table. For each primary key, you must provide
+     * <i>all</i> of the key attributes. For example, with a simple primary key, you
+     * only need to provide the partition key value. For a composite key, you must
+     * provide <i>both</i> the partition key value and the sort key value.</p> </li>
+     * <li> <p> <code>ProjectionExpression</code> - A string that identifies one or
+     * more attributes to retrieve from the table. These attributes can include
+     * scalars, sets, or elements of a JSON document. The attributes in the expression
+     * must be separated by commas.</p> <p>If no attribute names are specified, then
+     * all attributes are returned. If any of the requested attributes are not found,
+     * they do not appear in the result.</p> <p>For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Accessing
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> </li>
+     * <li> <p> <code>AttributesToGet</code> - This is a legacy parameter. Use
+     * <code>ProjectionExpression</code> instead. For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html">AttributesToGet</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>. </p> </li> </ul>
+     */
+    inline const Aws::Map<Aws::String, KeysAndAttributes>& GetRequestItems() const{ return m_requestItems; }
+
+    /**
+     * <p>A map of one or more table names and, for each table, a map that describes
+     * one or more items to retrieve from that table. Each table name can be used only
+     * once per <code>BatchGetItem</code> request.</p> <p>Each element in the map of
+     * items to retrieve consists of the following:</p> <ul> <li> <p>
+     * <code>ConsistentRead</code> - If <code>true</code>, a strongly consistent read
+     * is used; if <code>false</code> (the default), an eventually consistent read is
+     * used.</p> </li> <li> <p> <code>ExpressionAttributeNames</code> - One or more
+     * substitution tokens for attribute names in the <code>ProjectionExpression</code>
+     * parameter. The following are some use cases for using
+     * <code>ExpressionAttributeNames</code>:</p> <ul> <li> <p>To access an attribute
+     * whose name conflicts with a DynamoDB reserved word.</p> </li> <li> <p>To create
+     * a placeholder for repeating occurrences of an attribute name in an
+     * expression.</p> </li> <li> <p>To prevent special characters in an attribute name
+     * from being misinterpreted in an expression.</p> </li> </ul> <p>Use the <b>#</b>
+     * character in an expression to dereference an attribute name. For example,
+     * consider the following attribute name:</p> <ul> <li> <p> <code>Percentile</code>
+     * </p> </li> </ul> <p>The name of this attribute conflicts with a reserved word,
+     * so it cannot be used directly in an expression. (For the complete list of
+     * reserved words, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved
+     * Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this,
+     * you could specify the following for <code>ExpressionAttributeNames</code>:</p>
+     * <ul> <li> <p> <code>{"#P":"Percentile"}</code> </p> </li> </ul> <p>You could
+     * then use this substitution in an expression, as in this example:</p> <ul> <li>
+     * <p> <code>#P = :val</code> </p> </li> </ul>  <p>Tokens that begin with the
+     * <b>:</b> character are <i>expression attribute values</i>, which are
+     * placeholders for the actual value at runtime.</p>  <p>For more
+     * information about expression attribute names, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Accessing
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> </li>
+     * <li> <p> <code>Keys</code> - An array of primary key attribute values that
+     * define specific items in the table. For each primary key, you must provide
+     * <i>all</i> of the key attributes. For example, with a simple primary key, you
+     * only need to provide the partition key value. For a composite key, you must
+     * provide <i>both</i> the partition key value and the sort key value.</p> </li>
+     * <li> <p> <code>ProjectionExpression</code> - A string that identifies one or
+     * more attributes to retrieve from the table. These attributes can include
+     * scalars, sets, or elements of a JSON document. The attributes in the expression
+     * must be separated by commas.</p> <p>If no attribute names are specified, then
+     * all attributes are returned. If any of the requested attributes are not found,
+     * they do not appear in the result.</p> <p>For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Accessing
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> </li>
+     * <li> <p> <code>AttributesToGet</code> - This is a legacy parameter. Use
+     * <code>ProjectionExpression</code> instead. For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html">AttributesToGet</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>. </p> </li> </ul>
+     */
+    inline bool RequestItemsHasBeenSet() const { return m_requestItemsHasBeenSet; }
+
+    /**
+     * <p>A map of one or more table names and, for each table, a map that describes
+     * one or more items to retrieve from that table. Each table name can be used only
+     * once per <code>BatchGetItem</code> request.</p> <p>Each element in the map of
+     * items to retrieve consists of the following:</p> <ul> <li> <p>
+     * <code>ConsistentRead</code> - If <code>true</code>, a strongly consistent read
+     * is used; if <code>false</code> (the default), an eventually consistent read is
+     * used.</p> </li> <li> <p> <code>ExpressionAttributeNames</code> - One or more
+     * substitution tokens for attribute names in the <code>ProjectionExpression</code>
+     * parameter. The following are some use cases for using
+     * <code>ExpressionAttributeNames</code>:</p> <ul> <li> <p>To access an attribute
+     * whose name conflicts with a DynamoDB reserved word.</p> </li> <li> <p>To create
+     * a placeholder for repeating occurrences of an attribute name in an
+     * expression.</p> </li> <li> <p>To prevent special characters in an attribute name
+     * from being misinterpreted in an expression.</p> </li> </ul> <p>Use the <b>#</b>
+     * character in an expression to dereference an attribute name. For example,
+     * consider the following attribute name:</p> <ul> <li> <p> <code>Percentile</code>
+     * </p> </li> </ul> <p>The name of this attribute conflicts with a reserved word,
+     * so it cannot be used directly in an expression. (For the complete list of
+     * reserved words, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved
+     * Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this,
+     * you could specify the following for <code>ExpressionAttributeNames</code>:</p>
+     * <ul> <li> <p> <code>{"#P":"Percentile"}</code> </p> </li> </ul> <p>You could
+     * then use this substitution in an expression, as in this example:</p> <ul> <li>
+     * <p> <code>#P = :val</code> </p> </li> </ul>  <p>Tokens that begin with the
+     * <b>:</b> character are <i>expression attribute values</i>, which are
+     * placeholders for the actual value at runtime.</p>  <p>For more
+     * information about expression attribute names, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Accessing
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> </li>
+     * <li> <p> <code>Keys</code> - An array of primary key attribute values that
+     * define specific items in the table. For each primary key, you must provide
+     * <i>all</i> of the key attributes. For example, with a simple primary key, you
+     * only need to provide the partition key value. For a composite key, you must
+     * provide <i>both</i> the partition key value and the sort key value.</p> </li>
+     * <li> <p> <code>ProjectionExpression</code> - A string that identifies one or
+     * more attributes to retrieve from the table. These attributes can include
+     * scalars, sets, or elements of a JSON document. The attributes in the expression
+     * must be separated by commas.</p> <p>If no attribute names are specified, then
+     * all attributes are returned. If any of the requested attributes are not found,
+     * they do not appear in the result.</p> <p>For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Accessing
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> </li>
+     * <li> <p> <code>AttributesToGet</code> - This is a legacy parameter. Use
+     * <code>ProjectionExpression</code> instead. For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html">AttributesToGet</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>. </p> </li> </ul>
+     */
+    inline void SetRequestItems(const Aws::Map<Aws::String, KeysAndAttributes>& value) { m_requestItemsHasBeenSet = true; m_requestItems = value; }
+
+    /**
+     * <p>A map of one or more table names and, for each table, a map that describes
+     * one or more items to retrieve from that table. Each table name can be used only
+     * once per <code>BatchGetItem</code> request.</p> <p>Each element in the map of
+     * items to retrieve consists of the following:</p> <ul> <li> <p>
+     * <code>ConsistentRead</code> - If <code>true</code>, a strongly consistent read
+     * is used; if <code>false</code> (the default), an eventually consistent read is
+     * used.</p> </li> <li> <p> <code>ExpressionAttributeNames</code> - One or more
+     * substitution tokens for attribute names in the <code>ProjectionExpression</code>
+     * parameter. The following are some use cases for using
+     * <code>ExpressionAttributeNames</code>:</p> <ul> <li> <p>To access an attribute
+     * whose name conflicts with a DynamoDB reserved word.</p> </li> <li> <p>To create
+     * a placeholder for repeating occurrences of an attribute name in an
+     * expression.</p> </li> <li> <p>To prevent special characters in an attribute name
+     * from being misinterpreted in an expression.</p> </li> </ul> <p>Use the <b>#</b>
+     * character in an expression to dereference an attribute name. For example,
+     * consider the following attribute name:</p> <ul> <li> <p> <code>Percentile</code>
+     * </p> </li> </ul> <p>The name of this attribute conflicts with a reserved word,
+     * so it cannot be used directly in an expression. (For the complete list of
+     * reserved words, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved
+     * Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this,
+     * you could specify the following for <code>ExpressionAttributeNames</code>:</p>
+     * <ul> <li> <p> <code>{"#P":"Percentile"}</code> </p> </li> </ul> <p>You could
+     * then use this substitution in an expression, as in this example:</p> <ul> <li>
+     * <p> <code>#P = :val</code> </p> </li> </ul>  <p>Tokens that begin with the
+     * <b>:</b> character are <i>expression attribute values</i>, which are
+     * placeholders for the actual value at runtime.</p>  <p>For more
+     * information about expression attribute names, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Accessing
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> </li>
+     * <li> <p> <code>Keys</code> - An array of primary key attribute values that
+     * define specific items in the table. For each primary key, you must provide
+     * <i>all</i> of the key attributes. For example, with a simple primary key, you
+     * only need to provide the partition key value. For a composite key, you must
+     * provide <i>both</i> the partition key value and the sort key value.</p> </li>
+     * <li> <p> <code>ProjectionExpression</code> - A string that identifies one or
+     * more attributes to retrieve from the table. These attributes can include
+     * scalars, sets, or elements of a JSON document. The attributes in the expression
+     * must be separated by commas.</p> <p>If no attribute names are specified, then
+     * all attributes are returned. If any of the requested attributes are not found,
+     * they do not appear in the result.</p> <p>For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Accessing
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> </li>
+     * <li> <p> <code>AttributesToGet</code> - This is a legacy parameter. Use
+     * <code>ProjectionExpression</code> instead. For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html">AttributesToGet</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>. </p> </li> </ul>
+     */
+    inline void SetRequestItems(Aws::Map<Aws::String, KeysAndAttributes>&& value) { m_requestItemsHasBeenSet = true; m_requestItems = std::move(value); }
+
+    /**
+     * <p>A map of one or more table names and, for each table, a map that describes
+     * one or more items to retrieve from that table. Each table name can be used only
+     * once per <code>BatchGetItem</code> request.</p> <p>Each element in the map of
+     * items to retrieve consists of the following:</p> <ul> <li> <p>
+     * <code>ConsistentRead</code> - If <code>true</code>, a strongly consistent read
+     * is used; if <code>false</code> (the default), an eventually consistent read is
+     * used.</p> </li> <li> <p> <code>ExpressionAttributeNames</code> - One or more
+     * substitution tokens for attribute names in the <code>ProjectionExpression</code>
+     * parameter. The following are some use cases for using
+     * <code>ExpressionAttributeNames</code>:</p> <ul> <li> <p>To access an attribute
+     * whose name conflicts with a DynamoDB reserved word.</p> </li> <li> <p>To create
+     * a placeholder for repeating occurrences of an attribute name in an
+     * expression.</p> </li> <li> <p>To prevent special characters in an attribute name
+     * from being misinterpreted in an expression.</p> </li> </ul> <p>Use the <b>#</b>
+     * character in an expression to dereference an attribute name. For example,
+     * consider the following attribute name:</p> <ul> <li> <p> <code>Percentile</code>
+     * </p> </li> </ul> <p>The name of this attribute conflicts with a reserved word,
+     * so it cannot be used directly in an expression. (For the complete list of
+     * reserved words, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved
+     * Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this,
+     * you could specify the following for <code>ExpressionAttributeNames</code>:</p>
+     * <ul> <li> <p> <code>{"#P":"Percentile"}</code> </p> </li> </ul> <p>You could
+     * then use this substitution in an expression, as in this example:</p> <ul> <li>
+     * <p> <code>#P = :val</code> </p> </li> </ul>  <p>Tokens that begin with the
+     * <b>:</b> character are <i>expression attribute values</i>, which are
+     * placeholders for the actual value at runtime.</p>  <p>For more
+     * information about expression attribute names, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Accessing
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> </li>
+     * <li> <p> <code>Keys</code> - An array of primary key attribute values that
+     * define specific items in the table. For each primary key, you must provide
+     * <i>all</i> of the key attributes. For example, with a simple primary key, you
+     * only need to provide the partition key value. For a composite key, you must
+     * provide <i>both</i> the partition key value and the sort key value.</p> </li>
+     * <li> <p> <code>ProjectionExpression</code> - A string that identifies one or
+     * more attributes to retrieve from the table. These attributes can include
+     * scalars, sets, or elements of a JSON document. The attributes in the expression
+     * must be separated by commas.</p> <p>If no attribute names are specified, then
+     * all attributes are returned. If any of the requested attributes are not found,
+     * they do not appear in the result.</p> <p>For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Accessing
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> </li>
+     * <li> <p> <code>AttributesToGet</code> - This is a legacy parameter. Use
+     * <code>ProjectionExpression</code> instead. For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html">AttributesToGet</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>. </p> </li> </ul>
+     */
+    inline BatchGetItemRequest& WithRequestItems(const Aws::Map<Aws::String, KeysAndAttributes>& value) { SetRequestItems(value); return *this;}
+
+    /**
+     * <p>A map of one or more table names and, for each table, a map that describes
+     * one or more items to retrieve from that table. Each table name can be used only
+     * once per <code>BatchGetItem</code> request.</p> <p>Each element in the map of
+     * items to retrieve consists of the following:</p> <ul> <li> <p>
+     * <code>ConsistentRead</code> - If <code>true</code>, a strongly consistent read
+     * is used; if <code>false</code> (the default), an eventually consistent read is
+     * used.</p> </li> <li> <p> <code>ExpressionAttributeNames</code> - One or more
+     * substitution tokens for attribute names in the <code>ProjectionExpression</code>
+     * parameter. The following are some use cases for using
+     * <code>ExpressionAttributeNames</code>:</p> <ul> <li> <p>To access an attribute
+     * whose name conflicts with a DynamoDB reserved word.</p> </li> <li> <p>To create
+     * a placeholder for repeating occurrences of an attribute name in an
+     * expression.</p> </li> <li> <p>To prevent special characters in an attribute name
+     * from being misinterpreted in an expression.</p> </li> </ul> <p>Use the <b>#</b>
+     * character in an expression to dereference an attribute name. For example,
+     * consider the following attribute name:</p> <ul> <li> <p> <code>Percentile</code>
+     * </p> </li> </ul> <p>The name of this attribute conflicts with a reserved word,
+     * so it cannot be used directly in an expression. (For the complete list of
+     * reserved words, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved
+     * Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this,
+     * you could specify the following for <code>ExpressionAttributeNames</code>:</p>
+     * <ul> <li> <p> <code>{"#P":"Percentile"}</code> </p> </li> </ul> <p>You could
+     * then use this substitution in an expression, as in this example:</p> <ul> <li>
+     * <p> <code>#P = :val</code> </p> </li> </ul>  <p>Tokens that begin with the
+     * <b>:</b> character are <i>expression attribute values</i>, which are
+     * placeholders for the actual value at runtime.</p>  <p>For more
+     * information about expression attribute names, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Accessing
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> </li>
+     * <li> <p> <code>Keys</code> - An array of primary key attribute values that
+     * define specific items in the table. For each primary key, you must provide
+     * <i>all</i> of the key attributes. For example, with a simple primary key, you
+     * only need to provide the partition key value. For a composite key, you must
+     * provide <i>both</i> the partition key value and the sort key value.</p> </li>
+     * <li> <p> <code>ProjectionExpression</code> - A string that identifies one or
+     * more attributes to retrieve from the table. These attributes can include
+     * scalars, sets, or elements of a JSON document. The attributes in the expression
+     * must be separated by commas.</p> <p>If no attribute names are specified, then
+     * all attributes are returned. If any of the requested attributes are not found,
+     * they do not appear in the result.</p> <p>For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Accessing
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> </li>
+     * <li> <p> <code>AttributesToGet</code> - This is a legacy parameter. Use
+     * <code>ProjectionExpression</code> instead. For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html">AttributesToGet</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>. </p> </li> </ul>
+     */
+    inline BatchGetItemRequest& WithRequestItems(Aws::Map<Aws::String, KeysAndAttributes>&& value) { SetRequestItems(std::move(value)); return *this;}
+
+    /**
+     * <p>A map of one or more table names and, for each table, a map that describes
+     * one or more items to retrieve from that table. Each table name can be used only
+     * once per <code>BatchGetItem</code> request.</p> <p>Each element in the map of
+     * items to retrieve consists of the following:</p> <ul> <li> <p>
+     * <code>ConsistentRead</code> - If <code>true</code>, a strongly consistent read
+     * is used; if <code>false</code> (the default), an eventually consistent read is
+     * used.</p> </li> <li> <p> <code>ExpressionAttributeNames</code> - One or more
+     * substitution tokens for attribute names in the <code>ProjectionExpression</code>
+     * parameter. The following are some use cases for using
+     * <code>ExpressionAttributeNames</code>:</p> <ul> <li> <p>To access an attribute
+     * whose name conflicts with a DynamoDB reserved word.</p> </li> <li> <p>To create
+     * a placeholder for repeating occurrences of an attribute name in an
+     * expression.</p> </li> <li> <p>To prevent special characters in an attribute name
+     * from being misinterpreted in an expression.</p> </li> </ul> <p>Use the <b>#</b>
+     * character in an expression to dereference an attribute name. For example,
+     * consider the following attribute name:</p> <ul> <li> <p> <code>Percentile</code>
+     * </p> </li> </ul> <p>The name of this attribute conflicts with a reserved word,
+     * so it cannot be used directly in an expression. (For the complete list of
+     * reserved words, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved
+     * Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this,
+     * you could specify the following for <code>ExpressionAttributeNames</code>:</p>
+     * <ul> <li> <p> <code>{"#P":"Percentile"}</code> </p> </li> </ul> <p>You could
+     * then use this substitution in an expression, as in this example:</p> <ul> <li>
+     * <p> <code>#P = :val</code> </p> </li> </ul>  <p>Tokens that begin with the
+     * <b>:</b> character are <i>expression attribute values</i>, which are
+     * placeholders for the actual value at runtime.</p>  <p>For more
+     * information about expression attribute names, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Accessing
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> </li>
+     * <li> <p> <code>Keys</code> - An array of primary key attribute values that
+     * define specific items in the table. For each primary key, you must provide
+     * <i>all</i> of the key attributes. For example, with a simple primary key, you
+     * only need to provide the partition key value. For a composite key, you must
+     * provide <i>both</i> the partition key value and the sort key value.</p> </li>
+     * <li> <p> <code>ProjectionExpression</code> - A string that identifies one or
+     * more attributes to retrieve from the table. These attributes can include
+     * scalars, sets, or elements of a JSON document. The attributes in the expression
+     * must be separated by commas.</p> <p>If no attribute names are specified, then
+     * all attributes are returned. If any of the requested attributes are not found,
+     * they do not appear in the result.</p> <p>For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Accessing
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> </li>
+     * <li> <p> <code>AttributesToGet</code> - This is a legacy parameter. Use
+     * <code>ProjectionExpression</code> instead. For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html">AttributesToGet</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>. </p> </li> </ul>
+     */
+    inline BatchGetItemRequest& AddRequestItems(const Aws::String& key, const KeysAndAttributes& value) { m_requestItemsHasBeenSet = true; m_requestItems.emplace(key, value); return *this; }
+
+    /**
+     * <p>A map of one or more table names and, for each table, a map that describes
+     * one or more items to retrieve from that table. Each table name can be used only
+     * once per <code>BatchGetItem</code> request.</p> <p>Each element in the map of
+     * items to retrieve consists of the following:</p> <ul> <li> <p>
+     * <code>ConsistentRead</code> - If <code>true</code>, a strongly consistent read
+     * is used; if <code>false</code> (the default), an eventually consistent read is
+     * used.</p> </li> <li> <p> <code>ExpressionAttributeNames</code> - One or more
+     * substitution tokens for attribute names in the <code>ProjectionExpression</code>
+     * parameter. The following are some use cases for using
+     * <code>ExpressionAttributeNames</code>:</p> <ul> <li> <p>To access an attribute
+     * whose name conflicts with a DynamoDB reserved word.</p> </li> <li> <p>To create
+     * a placeholder for repeating occurrences of an attribute name in an
+     * expression.</p> </li> <li> <p>To prevent special characters in an attribute name
+     * from being misinterpreted in an expression.</p> </li> </ul> <p>Use the <b>#</b>
+     * character in an expression to dereference an attribute name. For example,
+     * consider the following attribute name:</p> <ul> <li> <p> <code>Percentile</code>
+     * </p> </li> </ul> <p>The name of this attribute conflicts with a reserved word,
+     * so it cannot be used directly in an expression. (For the complete list of
+     * reserved words, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved
+     * Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this,
+     * you could specify the following for <code>ExpressionAttributeNames</code>:</p>
+     * <ul> <li> <p> <code>{"#P":"Percentile"}</code> </p> </li> </ul> <p>You could
+     * then use this substitution in an expression, as in this example:</p> <ul> <li>
+     * <p> <code>#P = :val</code> </p> </li> </ul>  <p>Tokens that begin with the
+     * <b>:</b> character are <i>expression attribute values</i>, which are
+     * placeholders for the actual value at runtime.</p>  <p>For more
+     * information about expression attribute names, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Accessing
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> </li>
+     * <li> <p> <code>Keys</code> - An array of primary key attribute values that
+     * define specific items in the table. For each primary key, you must provide
+     * <i>all</i> of the key attributes. For example, with a simple primary key, you
+     * only need to provide the partition key value. For a composite key, you must
+     * provide <i>both</i> the partition key value and the sort key value.</p> </li>
+     * <li> <p> <code>ProjectionExpression</code> - A string that identifies one or
+     * more attributes to retrieve from the table. These attributes can include
+     * scalars, sets, or elements of a JSON document. The attributes in the expression
+     * must be separated by commas.</p> <p>If no attribute names are specified, then
+     * all attributes are returned. If any of the requested attributes are not found,
+     * they do not appear in the result.</p> <p>For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Accessing
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> </li>
+     * <li> <p> <code>AttributesToGet</code> - This is a legacy parameter. Use
+     * <code>ProjectionExpression</code> instead. For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html">AttributesToGet</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>. </p> </li> </ul>
+     */
+    inline BatchGetItemRequest& AddRequestItems(Aws::String&& key, const KeysAndAttributes& value) { m_requestItemsHasBeenSet = true; m_requestItems.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>A map of one or more table names and, for each table, a map that describes
+     * one or more items to retrieve from that table. Each table name can be used only
+     * once per <code>BatchGetItem</code> request.</p> <p>Each element in the map of
+     * items to retrieve consists of the following:</p> <ul> <li> <p>
+     * <code>ConsistentRead</code> - If <code>true</code>, a strongly consistent read
+     * is used; if <code>false</code> (the default), an eventually consistent read is
+     * used.</p> </li> <li> <p> <code>ExpressionAttributeNames</code> - One or more
+     * substitution tokens for attribute names in the <code>ProjectionExpression</code>
+     * parameter. The following are some use cases for using
+     * <code>ExpressionAttributeNames</code>:</p> <ul> <li> <p>To access an attribute
+     * whose name conflicts with a DynamoDB reserved word.</p> </li> <li> <p>To create
+     * a placeholder for repeating occurrences of an attribute name in an
+     * expression.</p> </li> <li> <p>To prevent special characters in an attribute name
+     * from being misinterpreted in an expression.</p> </li> </ul> <p>Use the <b>#</b>
+     * character in an expression to dereference an attribute name. For example,
+     * consider the following attribute name:</p> <ul> <li> <p> <code>Percentile</code>
+     * </p> </li> </ul> <p>The name of this attribute conflicts with a reserved word,
+     * so it cannot be used directly in an expression. (For the complete list of
+     * reserved words, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved
+     * Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this,
+     * you could specify the following for <code>ExpressionAttributeNames</code>:</p>
+     * <ul> <li> <p> <code>{"#P":"Percentile"}</code> </p> </li> </ul> <p>You could
+     * then use this substitution in an expression, as in this example:</p> <ul> <li>
+     * <p> <code>#P = :val</code> </p> </li> </ul>  <p>Tokens that begin with the
+     * <b>:</b> character are <i>expression attribute values</i>, which are
+     * placeholders for the actual value at runtime.</p>  <p>For more
+     * information about expression attribute names, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Accessing
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> </li>
+     * <li> <p> <code>Keys</code> - An array of primary key attribute values that
+     * define specific items in the table. For each primary key, you must provide
+     * <i>all</i> of the key attributes. For example, with a simple primary key, you
+     * only need to provide the partition key value. For a composite key, you must
+     * provide <i>both</i> the partition key value and the sort key value.</p> </li>
+     * <li> <p> <code>ProjectionExpression</code> - A string that identifies one or
+     * more attributes to retrieve from the table. These attributes can include
+     * scalars, sets, or elements of a JSON document. The attributes in the expression
+     * must be separated by commas.</p> <p>If no attribute names are specified, then
+     * all attributes are returned. If any of the requested attributes are not found,
+     * they do not appear in the result.</p> <p>For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Accessing
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> </li>
+     * <li> <p> <code>AttributesToGet</code> - This is a legacy parameter. Use
+     * <code>ProjectionExpression</code> instead. For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html">AttributesToGet</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>. </p> </li> </ul>
+     */
+    inline BatchGetItemRequest& AddRequestItems(const Aws::String& key, KeysAndAttributes&& value) { m_requestItemsHasBeenSet = true; m_requestItems.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A map of one or more table names and, for each table, a map that describes
+     * one or more items to retrieve from that table. Each table name can be used only
+     * once per <code>BatchGetItem</code> request.</p> <p>Each element in the map of
+     * items to retrieve consists of the following:</p> <ul> <li> <p>
+     * <code>ConsistentRead</code> - If <code>true</code>, a strongly consistent read
+     * is used; if <code>false</code> (the default), an eventually consistent read is
+     * used.</p> </li> <li> <p> <code>ExpressionAttributeNames</code> - One or more
+     * substitution tokens for attribute names in the <code>ProjectionExpression</code>
+     * parameter. The following are some use cases for using
+     * <code>ExpressionAttributeNames</code>:</p> <ul> <li> <p>To access an attribute
+     * whose name conflicts with a DynamoDB reserved word.</p> </li> <li> <p>To create
+     * a placeholder for repeating occurrences of an attribute name in an
+     * expression.</p> </li> <li> <p>To prevent special characters in an attribute name
+     * from being misinterpreted in an expression.</p> </li> </ul> <p>Use the <b>#</b>
+     * character in an expression to dereference an attribute name. For example,
+     * consider the following attribute name:</p> <ul> <li> <p> <code>Percentile</code>
+     * </p> </li> </ul> <p>The name of this attribute conflicts with a reserved word,
+     * so it cannot be used directly in an expression. (For the complete list of
+     * reserved words, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved
+     * Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this,
+     * you could specify the following for <code>ExpressionAttributeNames</code>:</p>
+     * <ul> <li> <p> <code>{"#P":"Percentile"}</code> </p> </li> </ul> <p>You could
+     * then use this substitution in an expression, as in this example:</p> <ul> <li>
+     * <p> <code>#P = :val</code> </p> </li> </ul>  <p>Tokens that begin with the
+     * <b>:</b> character are <i>expression attribute values</i>, which are
+     * placeholders for the actual value at runtime.</p>  <p>For more
+     * information about expression attribute names, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Accessing
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> </li>
+     * <li> <p> <code>Keys</code> - An array of primary key attribute values that
+     * define specific items in the table. For each primary key, you must provide
+     * <i>all</i> of the key attributes. For example, with a simple primary key, you
+     * only need to provide the partition key value. For a composite key, you must
+     * provide <i>both</i> the partition key value and the sort key value.</p> </li>
+     * <li> <p> <code>ProjectionExpression</code> - A string that identifies one or
+     * more attributes to retrieve from the table. These attributes can include
+     * scalars, sets, or elements of a JSON document. The attributes in the expression
+     * must be separated by commas.</p> <p>If no attribute names are specified, then
+     * all attributes are returned. If any of the requested attributes are not found,
+     * they do not appear in the result.</p> <p>For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Accessing
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> </li>
+     * <li> <p> <code>AttributesToGet</code> - This is a legacy parameter. Use
+     * <code>ProjectionExpression</code> instead. For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html">AttributesToGet</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>. </p> </li> </ul>
+     */
+    inline BatchGetItemRequest& AddRequestItems(Aws::String&& key, KeysAndAttributes&& value) { m_requestItemsHasBeenSet = true; m_requestItems.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>A map of one or more table names and, for each table, a map that describes
+     * one or more items to retrieve from that table. Each table name can be used only
+     * once per <code>BatchGetItem</code> request.</p> <p>Each element in the map of
+     * items to retrieve consists of the following:</p> <ul> <li> <p>
+     * <code>ConsistentRead</code> - If <code>true</code>, a strongly consistent read
+     * is used; if <code>false</code> (the default), an eventually consistent read is
+     * used.</p> </li> <li> <p> <code>ExpressionAttributeNames</code> - One or more
+     * substitution tokens for attribute names in the <code>ProjectionExpression</code>
+     * parameter. The following are some use cases for using
+     * <code>ExpressionAttributeNames</code>:</p> <ul> <li> <p>To access an attribute
+     * whose name conflicts with a DynamoDB reserved word.</p> </li> <li> <p>To create
+     * a placeholder for repeating occurrences of an attribute name in an
+     * expression.</p> </li> <li> <p>To prevent special characters in an attribute name
+     * from being misinterpreted in an expression.</p> </li> </ul> <p>Use the <b>#</b>
+     * character in an expression to dereference an attribute name. For example,
+     * consider the following attribute name:</p> <ul> <li> <p> <code>Percentile</code>
+     * </p> </li> </ul> <p>The name of this attribute conflicts with a reserved word,
+     * so it cannot be used directly in an expression. (For the complete list of
+     * reserved words, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved
+     * Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this,
+     * you could specify the following for <code>ExpressionAttributeNames</code>:</p>
+     * <ul> <li> <p> <code>{"#P":"Percentile"}</code> </p> </li> </ul> <p>You could
+     * then use this substitution in an expression, as in this example:</p> <ul> <li>
+     * <p> <code>#P = :val</code> </p> </li> </ul>  <p>Tokens that begin with the
+     * <b>:</b> character are <i>expression attribute values</i>, which are
+     * placeholders for the actual value at runtime.</p>  <p>For more
+     * information about expression attribute names, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Accessing
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> </li>
+     * <li> <p> <code>Keys</code> - An array of primary key attribute values that
+     * define specific items in the table. For each primary key, you must provide
+     * <i>all</i> of the key attributes. For example, with a simple primary key, you
+     * only need to provide the partition key value. For a composite key, you must
+     * provide <i>both</i> the partition key value and the sort key value.</p> </li>
+     * <li> <p> <code>ProjectionExpression</code> - A string that identifies one or
+     * more attributes to retrieve from the table. These attributes can include
+     * scalars, sets, or elements of a JSON document. The attributes in the expression
+     * must be separated by commas.</p> <p>If no attribute names are specified, then
+     * all attributes are returned. If any of the requested attributes are not found,
+     * they do not appear in the result.</p> <p>For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Accessing
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> </li>
+     * <li> <p> <code>AttributesToGet</code> - This is a legacy parameter. Use
+     * <code>ProjectionExpression</code> instead. For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html">AttributesToGet</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>. </p> </li> </ul>
+     */
+    inline BatchGetItemRequest& AddRequestItems(const char* key, KeysAndAttributes&& value) { m_requestItemsHasBeenSet = true; m_requestItems.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A map of one or more table names and, for each table, a map that describes
+     * one or more items to retrieve from that table. Each table name can be used only
+     * once per <code>BatchGetItem</code> request.</p> <p>Each element in the map of
+     * items to retrieve consists of the following:</p> <ul> <li> <p>
+     * <code>ConsistentRead</code> - If <code>true</code>, a strongly consistent read
+     * is used; if <code>false</code> (the default), an eventually consistent read is
+     * used.</p> </li> <li> <p> <code>ExpressionAttributeNames</code> - One or more
+     * substitution tokens for attribute names in the <code>ProjectionExpression</code>
+     * parameter. The following are some use cases for using
+     * <code>ExpressionAttributeNames</code>:</p> <ul> <li> <p>To access an attribute
+     * whose name conflicts with a DynamoDB reserved word.</p> </li> <li> <p>To create
+     * a placeholder for repeating occurrences of an attribute name in an
+     * expression.</p> </li> <li> <p>To prevent special characters in an attribute name
+     * from being misinterpreted in an expression.</p> </li> </ul> <p>Use the <b>#</b>
+     * character in an expression to dereference an attribute name. For example,
+     * consider the following attribute name:</p> <ul> <li> <p> <code>Percentile</code>
+     * </p> </li> </ul> <p>The name of this attribute conflicts with a reserved word,
+     * so it cannot be used directly in an expression. (For the complete list of
+     * reserved words, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved
+     * Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this,
+     * you could specify the following for <code>ExpressionAttributeNames</code>:</p>
+     * <ul> <li> <p> <code>{"#P":"Percentile"}</code> </p> </li> </ul> <p>You could
+     * then use this substitution in an expression, as in this example:</p> <ul> <li>
+     * <p> <code>#P = :val</code> </p> </li> </ul>  <p>Tokens that begin with the
+     * <b>:</b> character are <i>expression attribute values</i>, which are
+     * placeholders for the actual value at runtime.</p>  <p>For more
+     * information about expression attribute names, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Accessing
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> </li>
+     * <li> <p> <code>Keys</code> - An array of primary key attribute values that
+     * define specific items in the table. For each primary key, you must provide
+     * <i>all</i> of the key attributes. For example, with a simple primary key, you
+     * only need to provide the partition key value. For a composite key, you must
+     * provide <i>both</i> the partition key value and the sort key value.</p> </li>
+     * <li> <p> <code>ProjectionExpression</code> - A string that identifies one or
+     * more attributes to retrieve from the table. These attributes can include
+     * scalars, sets, or elements of a JSON document. The attributes in the expression
+     * must be separated by commas.</p> <p>If no attribute names are specified, then
+     * all attributes are returned. If any of the requested attributes are not found,
+     * they do not appear in the result.</p> <p>For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Accessing
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> </li>
+     * <li> <p> <code>AttributesToGet</code> - This is a legacy parameter. Use
+     * <code>ProjectionExpression</code> instead. For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html">AttributesToGet</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>. </p> </li> </ul>
+     */
+    inline BatchGetItemRequest& AddRequestItems(const char* key, const KeysAndAttributes& value) { m_requestItemsHasBeenSet = true; m_requestItems.emplace(key, value); return *this; }
+
+
+    
+    inline const ReturnConsumedCapacity& GetReturnConsumedCapacity() const{ return m_returnConsumedCapacity; }
+
+    
+    inline bool ReturnConsumedCapacityHasBeenSet() const { return m_returnConsumedCapacityHasBeenSet; }
+
+    
+    inline void SetReturnConsumedCapacity(const ReturnConsumedCapacity& value) { m_returnConsumedCapacityHasBeenSet = true; m_returnConsumedCapacity = value; }
+
+    
+    inline void SetReturnConsumedCapacity(ReturnConsumedCapacity&& value) { m_returnConsumedCapacityHasBeenSet = true; m_returnConsumedCapacity = std::move(value); }
+
+    
+    inline BatchGetItemRequest& WithReturnConsumedCapacity(const ReturnConsumedCapacity& value) { SetReturnConsumedCapacity(value); return *this;}
+
+    
+    inline BatchGetItemRequest& WithReturnConsumedCapacity(ReturnConsumedCapacity&& value) { SetReturnConsumedCapacity(std::move(value)); return *this;}
+
+  private:
+
+    Aws::Map<Aws::String, KeysAndAttributes> m_requestItems;
+    bool m_requestItemsHasBeenSet;
+
+    ReturnConsumedCapacity m_returnConsumedCapacity;
+    bool m_returnConsumedCapacityHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/BatchGetItemResult.h

@@ -0,0 +1,408 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/dynamodb/model/KeysAndAttributes.h>
+#include <aws/dynamodb/model/ConsumedCapacity.h>
+#include <aws/dynamodb/model/AttributeValue.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+  /**
+   * <p>Represents the output of a <code>BatchGetItem</code> operation.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/BatchGetItemOutput">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API BatchGetItemResult
+  {
+  public:
+    BatchGetItemResult();
+    BatchGetItemResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    BatchGetItemResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>A map of table name to a list of items. Each object in <code>Responses</code>
+     * consists of a table name, along with a map of attribute data consisting of the
+     * data type and attribute value.</p>
+     */
+    inline const Aws::Map<Aws::String, Aws::Vector<Aws::Map<Aws::String, AttributeValue>>>& GetResponses() const{ return m_responses; }
+
+    /**
+     * <p>A map of table name to a list of items. Each object in <code>Responses</code>
+     * consists of a table name, along with a map of attribute data consisting of the
+     * data type and attribute value.</p>
+     */
+    inline void SetResponses(const Aws::Map<Aws::String, Aws::Vector<Aws::Map<Aws::String, AttributeValue>>>& value) { m_responses = value; }
+
+    /**
+     * <p>A map of table name to a list of items. Each object in <code>Responses</code>
+     * consists of a table name, along with a map of attribute data consisting of the
+     * data type and attribute value.</p>
+     */
+    inline void SetResponses(Aws::Map<Aws::String, Aws::Vector<Aws::Map<Aws::String, AttributeValue>>>&& value) { m_responses = std::move(value); }
+
+    /**
+     * <p>A map of table name to a list of items. Each object in <code>Responses</code>
+     * consists of a table name, along with a map of attribute data consisting of the
+     * data type and attribute value.</p>
+     */
+    inline BatchGetItemResult& WithResponses(const Aws::Map<Aws::String, Aws::Vector<Aws::Map<Aws::String, AttributeValue>>>& value) { SetResponses(value); return *this;}
+
+    /**
+     * <p>A map of table name to a list of items. Each object in <code>Responses</code>
+     * consists of a table name, along with a map of attribute data consisting of the
+     * data type and attribute value.</p>
+     */
+    inline BatchGetItemResult& WithResponses(Aws::Map<Aws::String, Aws::Vector<Aws::Map<Aws::String, AttributeValue>>>&& value) { SetResponses(std::move(value)); return *this;}
+
+    /**
+     * <p>A map of table name to a list of items. Each object in <code>Responses</code>
+     * consists of a table name, along with a map of attribute data consisting of the
+     * data type and attribute value.</p>
+     */
+    inline BatchGetItemResult& AddResponses(const Aws::String& key, const Aws::Vector<Aws::Map<Aws::String, AttributeValue>>& value) { m_responses.emplace(key, value); return *this; }
+
+    /**
+     * <p>A map of table name to a list of items. Each object in <code>Responses</code>
+     * consists of a table name, along with a map of attribute data consisting of the
+     * data type and attribute value.</p>
+     */
+    inline BatchGetItemResult& AddResponses(Aws::String&& key, const Aws::Vector<Aws::Map<Aws::String, AttributeValue>>& value) { m_responses.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>A map of table name to a list of items. Each object in <code>Responses</code>
+     * consists of a table name, along with a map of attribute data consisting of the
+     * data type and attribute value.</p>
+     */
+    inline BatchGetItemResult& AddResponses(const Aws::String& key, Aws::Vector<Aws::Map<Aws::String, AttributeValue>>&& value) { m_responses.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A map of table name to a list of items. Each object in <code>Responses</code>
+     * consists of a table name, along with a map of attribute data consisting of the
+     * data type and attribute value.</p>
+     */
+    inline BatchGetItemResult& AddResponses(Aws::String&& key, Aws::Vector<Aws::Map<Aws::String, AttributeValue>>&& value) { m_responses.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>A map of table name to a list of items. Each object in <code>Responses</code>
+     * consists of a table name, along with a map of attribute data consisting of the
+     * data type and attribute value.</p>
+     */
+    inline BatchGetItemResult& AddResponses(const char* key, Aws::Vector<Aws::Map<Aws::String, AttributeValue>>&& value) { m_responses.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A map of table name to a list of items. Each object in <code>Responses</code>
+     * consists of a table name, along with a map of attribute data consisting of the
+     * data type and attribute value.</p>
+     */
+    inline BatchGetItemResult& AddResponses(const char* key, const Aws::Vector<Aws::Map<Aws::String, AttributeValue>>& value) { m_responses.emplace(key, value); return *this; }
+
+
+    /**
+     * <p>A map of tables and their respective keys that were not processed with the
+     * current response. The <code>UnprocessedKeys</code> value is in the same form as
+     * <code>RequestItems</code>, so the value can be provided directly to a subsequent
+     * <code>BatchGetItem</code> operation. For more information, see
+     * <code>RequestItems</code> in the Request Parameters section.</p> <p>Each element
+     * consists of:</p> <ul> <li> <p> <code>Keys</code> - An array of primary key
+     * attribute values that define specific items in the table.</p> </li> <li> <p>
+     * <code>ProjectionExpression</code> - One or more attributes to be retrieved from
+     * the table or index. By default, all attributes are returned. If a requested
+     * attribute is not found, it does not appear in the result.</p> </li> <li> <p>
+     * <code>ConsistentRead</code> - The consistency of a read operation. If set to
+     * <code>true</code>, then a strongly consistent read is used; otherwise, an
+     * eventually consistent read is used.</p> </li> </ul> <p>If there are no
+     * unprocessed keys remaining, the response contains an empty
+     * <code>UnprocessedKeys</code> map.</p>
+     */
+    inline const Aws::Map<Aws::String, KeysAndAttributes>& GetUnprocessedKeys() const{ return m_unprocessedKeys; }
+
+    /**
+     * <p>A map of tables and their respective keys that were not processed with the
+     * current response. The <code>UnprocessedKeys</code> value is in the same form as
+     * <code>RequestItems</code>, so the value can be provided directly to a subsequent
+     * <code>BatchGetItem</code> operation. For more information, see
+     * <code>RequestItems</code> in the Request Parameters section.</p> <p>Each element
+     * consists of:</p> <ul> <li> <p> <code>Keys</code> - An array of primary key
+     * attribute values that define specific items in the table.</p> </li> <li> <p>
+     * <code>ProjectionExpression</code> - One or more attributes to be retrieved from
+     * the table or index. By default, all attributes are returned. If a requested
+     * attribute is not found, it does not appear in the result.</p> </li> <li> <p>
+     * <code>ConsistentRead</code> - The consistency of a read operation. If set to
+     * <code>true</code>, then a strongly consistent read is used; otherwise, an
+     * eventually consistent read is used.</p> </li> </ul> <p>If there are no
+     * unprocessed keys remaining, the response contains an empty
+     * <code>UnprocessedKeys</code> map.</p>
+     */
+    inline void SetUnprocessedKeys(const Aws::Map<Aws::String, KeysAndAttributes>& value) { m_unprocessedKeys = value; }
+
+    /**
+     * <p>A map of tables and their respective keys that were not processed with the
+     * current response. The <code>UnprocessedKeys</code> value is in the same form as
+     * <code>RequestItems</code>, so the value can be provided directly to a subsequent
+     * <code>BatchGetItem</code> operation. For more information, see
+     * <code>RequestItems</code> in the Request Parameters section.</p> <p>Each element
+     * consists of:</p> <ul> <li> <p> <code>Keys</code> - An array of primary key
+     * attribute values that define specific items in the table.</p> </li> <li> <p>
+     * <code>ProjectionExpression</code> - One or more attributes to be retrieved from
+     * the table or index. By default, all attributes are returned. If a requested
+     * attribute is not found, it does not appear in the result.</p> </li> <li> <p>
+     * <code>ConsistentRead</code> - The consistency of a read operation. If set to
+     * <code>true</code>, then a strongly consistent read is used; otherwise, an
+     * eventually consistent read is used.</p> </li> </ul> <p>If there are no
+     * unprocessed keys remaining, the response contains an empty
+     * <code>UnprocessedKeys</code> map.</p>
+     */
+    inline void SetUnprocessedKeys(Aws::Map<Aws::String, KeysAndAttributes>&& value) { m_unprocessedKeys = std::move(value); }
+
+    /**
+     * <p>A map of tables and their respective keys that were not processed with the
+     * current response. The <code>UnprocessedKeys</code> value is in the same form as
+     * <code>RequestItems</code>, so the value can be provided directly to a subsequent
+     * <code>BatchGetItem</code> operation. For more information, see
+     * <code>RequestItems</code> in the Request Parameters section.</p> <p>Each element
+     * consists of:</p> <ul> <li> <p> <code>Keys</code> - An array of primary key
+     * attribute values that define specific items in the table.</p> </li> <li> <p>
+     * <code>ProjectionExpression</code> - One or more attributes to be retrieved from
+     * the table or index. By default, all attributes are returned. If a requested
+     * attribute is not found, it does not appear in the result.</p> </li> <li> <p>
+     * <code>ConsistentRead</code> - The consistency of a read operation. If set to
+     * <code>true</code>, then a strongly consistent read is used; otherwise, an
+     * eventually consistent read is used.</p> </li> </ul> <p>If there are no
+     * unprocessed keys remaining, the response contains an empty
+     * <code>UnprocessedKeys</code> map.</p>
+     */
+    inline BatchGetItemResult& WithUnprocessedKeys(const Aws::Map<Aws::String, KeysAndAttributes>& value) { SetUnprocessedKeys(value); return *this;}
+
+    /**
+     * <p>A map of tables and their respective keys that were not processed with the
+     * current response. The <code>UnprocessedKeys</code> value is in the same form as
+     * <code>RequestItems</code>, so the value can be provided directly to a subsequent
+     * <code>BatchGetItem</code> operation. For more information, see
+     * <code>RequestItems</code> in the Request Parameters section.</p> <p>Each element
+     * consists of:</p> <ul> <li> <p> <code>Keys</code> - An array of primary key
+     * attribute values that define specific items in the table.</p> </li> <li> <p>
+     * <code>ProjectionExpression</code> - One or more attributes to be retrieved from
+     * the table or index. By default, all attributes are returned. If a requested
+     * attribute is not found, it does not appear in the result.</p> </li> <li> <p>
+     * <code>ConsistentRead</code> - The consistency of a read operation. If set to
+     * <code>true</code>, then a strongly consistent read is used; otherwise, an
+     * eventually consistent read is used.</p> </li> </ul> <p>If there are no
+     * unprocessed keys remaining, the response contains an empty
+     * <code>UnprocessedKeys</code> map.</p>
+     */
+    inline BatchGetItemResult& WithUnprocessedKeys(Aws::Map<Aws::String, KeysAndAttributes>&& value) { SetUnprocessedKeys(std::move(value)); return *this;}
+
+    /**
+     * <p>A map of tables and their respective keys that were not processed with the
+     * current response. The <code>UnprocessedKeys</code> value is in the same form as
+     * <code>RequestItems</code>, so the value can be provided directly to a subsequent
+     * <code>BatchGetItem</code> operation. For more information, see
+     * <code>RequestItems</code> in the Request Parameters section.</p> <p>Each element
+     * consists of:</p> <ul> <li> <p> <code>Keys</code> - An array of primary key
+     * attribute values that define specific items in the table.</p> </li> <li> <p>
+     * <code>ProjectionExpression</code> - One or more attributes to be retrieved from
+     * the table or index. By default, all attributes are returned. If a requested
+     * attribute is not found, it does not appear in the result.</p> </li> <li> <p>
+     * <code>ConsistentRead</code> - The consistency of a read operation. If set to
+     * <code>true</code>, then a strongly consistent read is used; otherwise, an
+     * eventually consistent read is used.</p> </li> </ul> <p>If there are no
+     * unprocessed keys remaining, the response contains an empty
+     * <code>UnprocessedKeys</code> map.</p>
+     */
+    inline BatchGetItemResult& AddUnprocessedKeys(const Aws::String& key, const KeysAndAttributes& value) { m_unprocessedKeys.emplace(key, value); return *this; }
+
+    /**
+     * <p>A map of tables and their respective keys that were not processed with the
+     * current response. The <code>UnprocessedKeys</code> value is in the same form as
+     * <code>RequestItems</code>, so the value can be provided directly to a subsequent
+     * <code>BatchGetItem</code> operation. For more information, see
+     * <code>RequestItems</code> in the Request Parameters section.</p> <p>Each element
+     * consists of:</p> <ul> <li> <p> <code>Keys</code> - An array of primary key
+     * attribute values that define specific items in the table.</p> </li> <li> <p>
+     * <code>ProjectionExpression</code> - One or more attributes to be retrieved from
+     * the table or index. By default, all attributes are returned. If a requested
+     * attribute is not found, it does not appear in the result.</p> </li> <li> <p>
+     * <code>ConsistentRead</code> - The consistency of a read operation. If set to
+     * <code>true</code>, then a strongly consistent read is used; otherwise, an
+     * eventually consistent read is used.</p> </li> </ul> <p>If there are no
+     * unprocessed keys remaining, the response contains an empty
+     * <code>UnprocessedKeys</code> map.</p>
+     */
+    inline BatchGetItemResult& AddUnprocessedKeys(Aws::String&& key, const KeysAndAttributes& value) { m_unprocessedKeys.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>A map of tables and their respective keys that were not processed with the
+     * current response. The <code>UnprocessedKeys</code> value is in the same form as
+     * <code>RequestItems</code>, so the value can be provided directly to a subsequent
+     * <code>BatchGetItem</code> operation. For more information, see
+     * <code>RequestItems</code> in the Request Parameters section.</p> <p>Each element
+     * consists of:</p> <ul> <li> <p> <code>Keys</code> - An array of primary key
+     * attribute values that define specific items in the table.</p> </li> <li> <p>
+     * <code>ProjectionExpression</code> - One or more attributes to be retrieved from
+     * the table or index. By default, all attributes are returned. If a requested
+     * attribute is not found, it does not appear in the result.</p> </li> <li> <p>
+     * <code>ConsistentRead</code> - The consistency of a read operation. If set to
+     * <code>true</code>, then a strongly consistent read is used; otherwise, an
+     * eventually consistent read is used.</p> </li> </ul> <p>If there are no
+     * unprocessed keys remaining, the response contains an empty
+     * <code>UnprocessedKeys</code> map.</p>
+     */
+    inline BatchGetItemResult& AddUnprocessedKeys(const Aws::String& key, KeysAndAttributes&& value) { m_unprocessedKeys.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A map of tables and their respective keys that were not processed with the
+     * current response. The <code>UnprocessedKeys</code> value is in the same form as
+     * <code>RequestItems</code>, so the value can be provided directly to a subsequent
+     * <code>BatchGetItem</code> operation. For more information, see
+     * <code>RequestItems</code> in the Request Parameters section.</p> <p>Each element
+     * consists of:</p> <ul> <li> <p> <code>Keys</code> - An array of primary key
+     * attribute values that define specific items in the table.</p> </li> <li> <p>
+     * <code>ProjectionExpression</code> - One or more attributes to be retrieved from
+     * the table or index. By default, all attributes are returned. If a requested
+     * attribute is not found, it does not appear in the result.</p> </li> <li> <p>
+     * <code>ConsistentRead</code> - The consistency of a read operation. If set to
+     * <code>true</code>, then a strongly consistent read is used; otherwise, an
+     * eventually consistent read is used.</p> </li> </ul> <p>If there are no
+     * unprocessed keys remaining, the response contains an empty
+     * <code>UnprocessedKeys</code> map.</p>
+     */
+    inline BatchGetItemResult& AddUnprocessedKeys(Aws::String&& key, KeysAndAttributes&& value) { m_unprocessedKeys.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>A map of tables and their respective keys that were not processed with the
+     * current response. The <code>UnprocessedKeys</code> value is in the same form as
+     * <code>RequestItems</code>, so the value can be provided directly to a subsequent
+     * <code>BatchGetItem</code> operation. For more information, see
+     * <code>RequestItems</code> in the Request Parameters section.</p> <p>Each element
+     * consists of:</p> <ul> <li> <p> <code>Keys</code> - An array of primary key
+     * attribute values that define specific items in the table.</p> </li> <li> <p>
+     * <code>ProjectionExpression</code> - One or more attributes to be retrieved from
+     * the table or index. By default, all attributes are returned. If a requested
+     * attribute is not found, it does not appear in the result.</p> </li> <li> <p>
+     * <code>ConsistentRead</code> - The consistency of a read operation. If set to
+     * <code>true</code>, then a strongly consistent read is used; otherwise, an
+     * eventually consistent read is used.</p> </li> </ul> <p>If there are no
+     * unprocessed keys remaining, the response contains an empty
+     * <code>UnprocessedKeys</code> map.</p>
+     */
+    inline BatchGetItemResult& AddUnprocessedKeys(const char* key, KeysAndAttributes&& value) { m_unprocessedKeys.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A map of tables and their respective keys that were not processed with the
+     * current response. The <code>UnprocessedKeys</code> value is in the same form as
+     * <code>RequestItems</code>, so the value can be provided directly to a subsequent
+     * <code>BatchGetItem</code> operation. For more information, see
+     * <code>RequestItems</code> in the Request Parameters section.</p> <p>Each element
+     * consists of:</p> <ul> <li> <p> <code>Keys</code> - An array of primary key
+     * attribute values that define specific items in the table.</p> </li> <li> <p>
+     * <code>ProjectionExpression</code> - One or more attributes to be retrieved from
+     * the table or index. By default, all attributes are returned. If a requested
+     * attribute is not found, it does not appear in the result.</p> </li> <li> <p>
+     * <code>ConsistentRead</code> - The consistency of a read operation. If set to
+     * <code>true</code>, then a strongly consistent read is used; otherwise, an
+     * eventually consistent read is used.</p> </li> </ul> <p>If there are no
+     * unprocessed keys remaining, the response contains an empty
+     * <code>UnprocessedKeys</code> map.</p>
+     */
+    inline BatchGetItemResult& AddUnprocessedKeys(const char* key, const KeysAndAttributes& value) { m_unprocessedKeys.emplace(key, value); return *this; }
+
+
+    /**
+     * <p>The read capacity units consumed by the entire <code>BatchGetItem</code>
+     * operation.</p> <p>Each element consists of:</p> <ul> <li> <p>
+     * <code>TableName</code> - The table that consumed the provisioned throughput.</p>
+     * </li> <li> <p> <code>CapacityUnits</code> - The total number of capacity units
+     * consumed.</p> </li> </ul>
+     */
+    inline const Aws::Vector<ConsumedCapacity>& GetConsumedCapacity() const{ return m_consumedCapacity; }
+
+    /**
+     * <p>The read capacity units consumed by the entire <code>BatchGetItem</code>
+     * operation.</p> <p>Each element consists of:</p> <ul> <li> <p>
+     * <code>TableName</code> - The table that consumed the provisioned throughput.</p>
+     * </li> <li> <p> <code>CapacityUnits</code> - The total number of capacity units
+     * consumed.</p> </li> </ul>
+     */
+    inline void SetConsumedCapacity(const Aws::Vector<ConsumedCapacity>& value) { m_consumedCapacity = value; }
+
+    /**
+     * <p>The read capacity units consumed by the entire <code>BatchGetItem</code>
+     * operation.</p> <p>Each element consists of:</p> <ul> <li> <p>
+     * <code>TableName</code> - The table that consumed the provisioned throughput.</p>
+     * </li> <li> <p> <code>CapacityUnits</code> - The total number of capacity units
+     * consumed.</p> </li> </ul>
+     */
+    inline void SetConsumedCapacity(Aws::Vector<ConsumedCapacity>&& value) { m_consumedCapacity = std::move(value); }
+
+    /**
+     * <p>The read capacity units consumed by the entire <code>BatchGetItem</code>
+     * operation.</p> <p>Each element consists of:</p> <ul> <li> <p>
+     * <code>TableName</code> - The table that consumed the provisioned throughput.</p>
+     * </li> <li> <p> <code>CapacityUnits</code> - The total number of capacity units
+     * consumed.</p> </li> </ul>
+     */
+    inline BatchGetItemResult& WithConsumedCapacity(const Aws::Vector<ConsumedCapacity>& value) { SetConsumedCapacity(value); return *this;}
+
+    /**
+     * <p>The read capacity units consumed by the entire <code>BatchGetItem</code>
+     * operation.</p> <p>Each element consists of:</p> <ul> <li> <p>
+     * <code>TableName</code> - The table that consumed the provisioned throughput.</p>
+     * </li> <li> <p> <code>CapacityUnits</code> - The total number of capacity units
+     * consumed.</p> </li> </ul>
+     */
+    inline BatchGetItemResult& WithConsumedCapacity(Aws::Vector<ConsumedCapacity>&& value) { SetConsumedCapacity(std::move(value)); return *this;}
+
+    /**
+     * <p>The read capacity units consumed by the entire <code>BatchGetItem</code>
+     * operation.</p> <p>Each element consists of:</p> <ul> <li> <p>
+     * <code>TableName</code> - The table that consumed the provisioned throughput.</p>
+     * </li> <li> <p> <code>CapacityUnits</code> - The total number of capacity units
+     * consumed.</p> </li> </ul>
+     */
+    inline BatchGetItemResult& AddConsumedCapacity(const ConsumedCapacity& value) { m_consumedCapacity.push_back(value); return *this; }
+
+    /**
+     * <p>The read capacity units consumed by the entire <code>BatchGetItem</code>
+     * operation.</p> <p>Each element consists of:</p> <ul> <li> <p>
+     * <code>TableName</code> - The table that consumed the provisioned throughput.</p>
+     * </li> <li> <p> <code>CapacityUnits</code> - The total number of capacity units
+     * consumed.</p> </li> </ul>
+     */
+    inline BatchGetItemResult& AddConsumedCapacity(ConsumedCapacity&& value) { m_consumedCapacity.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::Map<Aws::String, Aws::Vector<Aws::Map<Aws::String, AttributeValue>>> m_responses;
+
+    Aws::Map<Aws::String, KeysAndAttributes> m_unprocessedKeys;
+
+    Aws::Vector<ConsumedCapacity> m_consumedCapacity;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/BatchWriteItemRequest.h

@@ -0,0 +1,440 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/DynamoDBRequest.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <aws/dynamodb/model/ReturnConsumedCapacity.h>
+#include <aws/dynamodb/model/ReturnItemCollectionMetrics.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/dynamodb/model/WriteRequest.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents the input of a <code>BatchWriteItem</code>
+   * operation.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/BatchWriteItemInput">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API BatchWriteItemRequest : public DynamoDBRequest
+  {
+  public:
+    BatchWriteItemRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "BatchWriteItem"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>A map of one or more table names and, for each table, a list of operations to
+     * be performed (<code>DeleteRequest</code> or <code>PutRequest</code>). Each
+     * element in the map consists of the following:</p> <ul> <li> <p>
+     * <code>DeleteRequest</code> - Perform a <code>DeleteItem</code> operation on the
+     * specified item. The item to be deleted is identified by a <code>Key</code>
+     * subelement:</p> <ul> <li> <p> <code>Key</code> - A map of primary key attribute
+     * values that uniquely identify the item. Each entry in this map consists of an
+     * attribute name and an attribute value. For each primary key, you must provide
+     * <i>all</i> of the key attributes. For example, with a simple primary key, you
+     * only need to provide a value for the partition key. For a composite primary key,
+     * you must provide values for <i>both</i> the partition key and the sort key.</p>
+     * </li> </ul> </li> <li> <p> <code>PutRequest</code> - Perform a
+     * <code>PutItem</code> operation on the specified item. The item to be put is
+     * identified by an <code>Item</code> subelement:</p> <ul> <li> <p>
+     * <code>Item</code> - A map of attributes and their values. Each entry in this map
+     * consists of an attribute name and an attribute value. Attribute values must not
+     * be null; string and binary type attributes must have lengths greater than zero;
+     * and set type attributes must not be empty. Requests that contain empty values
+     * are rejected with a <code>ValidationException</code> exception.</p> <p>If you
+     * specify any attributes that are part of an index key, then the data types for
+     * those attributes must match those of the schema in the table's attribute
+     * definition.</p> </li> </ul> </li> </ul>
+     */
+    inline const Aws::Map<Aws::String, Aws::Vector<WriteRequest>>& GetRequestItems() const{ return m_requestItems; }
+
+    /**
+     * <p>A map of one or more table names and, for each table, a list of operations to
+     * be performed (<code>DeleteRequest</code> or <code>PutRequest</code>). Each
+     * element in the map consists of the following:</p> <ul> <li> <p>
+     * <code>DeleteRequest</code> - Perform a <code>DeleteItem</code> operation on the
+     * specified item. The item to be deleted is identified by a <code>Key</code>
+     * subelement:</p> <ul> <li> <p> <code>Key</code> - A map of primary key attribute
+     * values that uniquely identify the item. Each entry in this map consists of an
+     * attribute name and an attribute value. For each primary key, you must provide
+     * <i>all</i> of the key attributes. For example, with a simple primary key, you
+     * only need to provide a value for the partition key. For a composite primary key,
+     * you must provide values for <i>both</i> the partition key and the sort key.</p>
+     * </li> </ul> </li> <li> <p> <code>PutRequest</code> - Perform a
+     * <code>PutItem</code> operation on the specified item. The item to be put is
+     * identified by an <code>Item</code> subelement:</p> <ul> <li> <p>
+     * <code>Item</code> - A map of attributes and their values. Each entry in this map
+     * consists of an attribute name and an attribute value. Attribute values must not
+     * be null; string and binary type attributes must have lengths greater than zero;
+     * and set type attributes must not be empty. Requests that contain empty values
+     * are rejected with a <code>ValidationException</code> exception.</p> <p>If you
+     * specify any attributes that are part of an index key, then the data types for
+     * those attributes must match those of the schema in the table's attribute
+     * definition.</p> </li> </ul> </li> </ul>
+     */
+    inline bool RequestItemsHasBeenSet() const { return m_requestItemsHasBeenSet; }
+
+    /**
+     * <p>A map of one or more table names and, for each table, a list of operations to
+     * be performed (<code>DeleteRequest</code> or <code>PutRequest</code>). Each
+     * element in the map consists of the following:</p> <ul> <li> <p>
+     * <code>DeleteRequest</code> - Perform a <code>DeleteItem</code> operation on the
+     * specified item. The item to be deleted is identified by a <code>Key</code>
+     * subelement:</p> <ul> <li> <p> <code>Key</code> - A map of primary key attribute
+     * values that uniquely identify the item. Each entry in this map consists of an
+     * attribute name and an attribute value. For each primary key, you must provide
+     * <i>all</i> of the key attributes. For example, with a simple primary key, you
+     * only need to provide a value for the partition key. For a composite primary key,
+     * you must provide values for <i>both</i> the partition key and the sort key.</p>
+     * </li> </ul> </li> <li> <p> <code>PutRequest</code> - Perform a
+     * <code>PutItem</code> operation on the specified item. The item to be put is
+     * identified by an <code>Item</code> subelement:</p> <ul> <li> <p>
+     * <code>Item</code> - A map of attributes and their values. Each entry in this map
+     * consists of an attribute name and an attribute value. Attribute values must not
+     * be null; string and binary type attributes must have lengths greater than zero;
+     * and set type attributes must not be empty. Requests that contain empty values
+     * are rejected with a <code>ValidationException</code> exception.</p> <p>If you
+     * specify any attributes that are part of an index key, then the data types for
+     * those attributes must match those of the schema in the table's attribute
+     * definition.</p> </li> </ul> </li> </ul>
+     */
+    inline void SetRequestItems(const Aws::Map<Aws::String, Aws::Vector<WriteRequest>>& value) { m_requestItemsHasBeenSet = true; m_requestItems = value; }
+
+    /**
+     * <p>A map of one or more table names and, for each table, a list of operations to
+     * be performed (<code>DeleteRequest</code> or <code>PutRequest</code>). Each
+     * element in the map consists of the following:</p> <ul> <li> <p>
+     * <code>DeleteRequest</code> - Perform a <code>DeleteItem</code> operation on the
+     * specified item. The item to be deleted is identified by a <code>Key</code>
+     * subelement:</p> <ul> <li> <p> <code>Key</code> - A map of primary key attribute
+     * values that uniquely identify the item. Each entry in this map consists of an
+     * attribute name and an attribute value. For each primary key, you must provide
+     * <i>all</i> of the key attributes. For example, with a simple primary key, you
+     * only need to provide a value for the partition key. For a composite primary key,
+     * you must provide values for <i>both</i> the partition key and the sort key.</p>
+     * </li> </ul> </li> <li> <p> <code>PutRequest</code> - Perform a
+     * <code>PutItem</code> operation on the specified item. The item to be put is
+     * identified by an <code>Item</code> subelement:</p> <ul> <li> <p>
+     * <code>Item</code> - A map of attributes and their values. Each entry in this map
+     * consists of an attribute name and an attribute value. Attribute values must not
+     * be null; string and binary type attributes must have lengths greater than zero;
+     * and set type attributes must not be empty. Requests that contain empty values
+     * are rejected with a <code>ValidationException</code> exception.</p> <p>If you
+     * specify any attributes that are part of an index key, then the data types for
+     * those attributes must match those of the schema in the table's attribute
+     * definition.</p> </li> </ul> </li> </ul>
+     */
+    inline void SetRequestItems(Aws::Map<Aws::String, Aws::Vector<WriteRequest>>&& value) { m_requestItemsHasBeenSet = true; m_requestItems = std::move(value); }
+
+    /**
+     * <p>A map of one or more table names and, for each table, a list of operations to
+     * be performed (<code>DeleteRequest</code> or <code>PutRequest</code>). Each
+     * element in the map consists of the following:</p> <ul> <li> <p>
+     * <code>DeleteRequest</code> - Perform a <code>DeleteItem</code> operation on the
+     * specified item. The item to be deleted is identified by a <code>Key</code>
+     * subelement:</p> <ul> <li> <p> <code>Key</code> - A map of primary key attribute
+     * values that uniquely identify the item. Each entry in this map consists of an
+     * attribute name and an attribute value. For each primary key, you must provide
+     * <i>all</i> of the key attributes. For example, with a simple primary key, you
+     * only need to provide a value for the partition key. For a composite primary key,
+     * you must provide values for <i>both</i> the partition key and the sort key.</p>
+     * </li> </ul> </li> <li> <p> <code>PutRequest</code> - Perform a
+     * <code>PutItem</code> operation on the specified item. The item to be put is
+     * identified by an <code>Item</code> subelement:</p> <ul> <li> <p>
+     * <code>Item</code> - A map of attributes and their values. Each entry in this map
+     * consists of an attribute name and an attribute value. Attribute values must not
+     * be null; string and binary type attributes must have lengths greater than zero;
+     * and set type attributes must not be empty. Requests that contain empty values
+     * are rejected with a <code>ValidationException</code> exception.</p> <p>If you
+     * specify any attributes that are part of an index key, then the data types for
+     * those attributes must match those of the schema in the table's attribute
+     * definition.</p> </li> </ul> </li> </ul>
+     */
+    inline BatchWriteItemRequest& WithRequestItems(const Aws::Map<Aws::String, Aws::Vector<WriteRequest>>& value) { SetRequestItems(value); return *this;}
+
+    /**
+     * <p>A map of one or more table names and, for each table, a list of operations to
+     * be performed (<code>DeleteRequest</code> or <code>PutRequest</code>). Each
+     * element in the map consists of the following:</p> <ul> <li> <p>
+     * <code>DeleteRequest</code> - Perform a <code>DeleteItem</code> operation on the
+     * specified item. The item to be deleted is identified by a <code>Key</code>
+     * subelement:</p> <ul> <li> <p> <code>Key</code> - A map of primary key attribute
+     * values that uniquely identify the item. Each entry in this map consists of an
+     * attribute name and an attribute value. For each primary key, you must provide
+     * <i>all</i> of the key attributes. For example, with a simple primary key, you
+     * only need to provide a value for the partition key. For a composite primary key,
+     * you must provide values for <i>both</i> the partition key and the sort key.</p>
+     * </li> </ul> </li> <li> <p> <code>PutRequest</code> - Perform a
+     * <code>PutItem</code> operation on the specified item. The item to be put is
+     * identified by an <code>Item</code> subelement:</p> <ul> <li> <p>
+     * <code>Item</code> - A map of attributes and their values. Each entry in this map
+     * consists of an attribute name and an attribute value. Attribute values must not
+     * be null; string and binary type attributes must have lengths greater than zero;
+     * and set type attributes must not be empty. Requests that contain empty values
+     * are rejected with a <code>ValidationException</code> exception.</p> <p>If you
+     * specify any attributes that are part of an index key, then the data types for
+     * those attributes must match those of the schema in the table's attribute
+     * definition.</p> </li> </ul> </li> </ul>
+     */
+    inline BatchWriteItemRequest& WithRequestItems(Aws::Map<Aws::String, Aws::Vector<WriteRequest>>&& value) { SetRequestItems(std::move(value)); return *this;}
+
+    /**
+     * <p>A map of one or more table names and, for each table, a list of operations to
+     * be performed (<code>DeleteRequest</code> or <code>PutRequest</code>). Each
+     * element in the map consists of the following:</p> <ul> <li> <p>
+     * <code>DeleteRequest</code> - Perform a <code>DeleteItem</code> operation on the
+     * specified item. The item to be deleted is identified by a <code>Key</code>
+     * subelement:</p> <ul> <li> <p> <code>Key</code> - A map of primary key attribute
+     * values that uniquely identify the item. Each entry in this map consists of an
+     * attribute name and an attribute value. For each primary key, you must provide
+     * <i>all</i> of the key attributes. For example, with a simple primary key, you
+     * only need to provide a value for the partition key. For a composite primary key,
+     * you must provide values for <i>both</i> the partition key and the sort key.</p>
+     * </li> </ul> </li> <li> <p> <code>PutRequest</code> - Perform a
+     * <code>PutItem</code> operation on the specified item. The item to be put is
+     * identified by an <code>Item</code> subelement:</p> <ul> <li> <p>
+     * <code>Item</code> - A map of attributes and their values. Each entry in this map
+     * consists of an attribute name and an attribute value. Attribute values must not
+     * be null; string and binary type attributes must have lengths greater than zero;
+     * and set type attributes must not be empty. Requests that contain empty values
+     * are rejected with a <code>ValidationException</code> exception.</p> <p>If you
+     * specify any attributes that are part of an index key, then the data types for
+     * those attributes must match those of the schema in the table's attribute
+     * definition.</p> </li> </ul> </li> </ul>
+     */
+    inline BatchWriteItemRequest& AddRequestItems(const Aws::String& key, const Aws::Vector<WriteRequest>& value) { m_requestItemsHasBeenSet = true; m_requestItems.emplace(key, value); return *this; }
+
+    /**
+     * <p>A map of one or more table names and, for each table, a list of operations to
+     * be performed (<code>DeleteRequest</code> or <code>PutRequest</code>). Each
+     * element in the map consists of the following:</p> <ul> <li> <p>
+     * <code>DeleteRequest</code> - Perform a <code>DeleteItem</code> operation on the
+     * specified item. The item to be deleted is identified by a <code>Key</code>
+     * subelement:</p> <ul> <li> <p> <code>Key</code> - A map of primary key attribute
+     * values that uniquely identify the item. Each entry in this map consists of an
+     * attribute name and an attribute value. For each primary key, you must provide
+     * <i>all</i> of the key attributes. For example, with a simple primary key, you
+     * only need to provide a value for the partition key. For a composite primary key,
+     * you must provide values for <i>both</i> the partition key and the sort key.</p>
+     * </li> </ul> </li> <li> <p> <code>PutRequest</code> - Perform a
+     * <code>PutItem</code> operation on the specified item. The item to be put is
+     * identified by an <code>Item</code> subelement:</p> <ul> <li> <p>
+     * <code>Item</code> - A map of attributes and their values. Each entry in this map
+     * consists of an attribute name and an attribute value. Attribute values must not
+     * be null; string and binary type attributes must have lengths greater than zero;
+     * and set type attributes must not be empty. Requests that contain empty values
+     * are rejected with a <code>ValidationException</code> exception.</p> <p>If you
+     * specify any attributes that are part of an index key, then the data types for
+     * those attributes must match those of the schema in the table's attribute
+     * definition.</p> </li> </ul> </li> </ul>
+     */
+    inline BatchWriteItemRequest& AddRequestItems(Aws::String&& key, const Aws::Vector<WriteRequest>& value) { m_requestItemsHasBeenSet = true; m_requestItems.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>A map of one or more table names and, for each table, a list of operations to
+     * be performed (<code>DeleteRequest</code> or <code>PutRequest</code>). Each
+     * element in the map consists of the following:</p> <ul> <li> <p>
+     * <code>DeleteRequest</code> - Perform a <code>DeleteItem</code> operation on the
+     * specified item. The item to be deleted is identified by a <code>Key</code>
+     * subelement:</p> <ul> <li> <p> <code>Key</code> - A map of primary key attribute
+     * values that uniquely identify the item. Each entry in this map consists of an
+     * attribute name and an attribute value. For each primary key, you must provide
+     * <i>all</i> of the key attributes. For example, with a simple primary key, you
+     * only need to provide a value for the partition key. For a composite primary key,
+     * you must provide values for <i>both</i> the partition key and the sort key.</p>
+     * </li> </ul> </li> <li> <p> <code>PutRequest</code> - Perform a
+     * <code>PutItem</code> operation on the specified item. The item to be put is
+     * identified by an <code>Item</code> subelement:</p> <ul> <li> <p>
+     * <code>Item</code> - A map of attributes and their values. Each entry in this map
+     * consists of an attribute name and an attribute value. Attribute values must not
+     * be null; string and binary type attributes must have lengths greater than zero;
+     * and set type attributes must not be empty. Requests that contain empty values
+     * are rejected with a <code>ValidationException</code> exception.</p> <p>If you
+     * specify any attributes that are part of an index key, then the data types for
+     * those attributes must match those of the schema in the table's attribute
+     * definition.</p> </li> </ul> </li> </ul>
+     */
+    inline BatchWriteItemRequest& AddRequestItems(const Aws::String& key, Aws::Vector<WriteRequest>&& value) { m_requestItemsHasBeenSet = true; m_requestItems.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A map of one or more table names and, for each table, a list of operations to
+     * be performed (<code>DeleteRequest</code> or <code>PutRequest</code>). Each
+     * element in the map consists of the following:</p> <ul> <li> <p>
+     * <code>DeleteRequest</code> - Perform a <code>DeleteItem</code> operation on the
+     * specified item. The item to be deleted is identified by a <code>Key</code>
+     * subelement:</p> <ul> <li> <p> <code>Key</code> - A map of primary key attribute
+     * values that uniquely identify the item. Each entry in this map consists of an
+     * attribute name and an attribute value. For each primary key, you must provide
+     * <i>all</i> of the key attributes. For example, with a simple primary key, you
+     * only need to provide a value for the partition key. For a composite primary key,
+     * you must provide values for <i>both</i> the partition key and the sort key.</p>
+     * </li> </ul> </li> <li> <p> <code>PutRequest</code> - Perform a
+     * <code>PutItem</code> operation on the specified item. The item to be put is
+     * identified by an <code>Item</code> subelement:</p> <ul> <li> <p>
+     * <code>Item</code> - A map of attributes and their values. Each entry in this map
+     * consists of an attribute name and an attribute value. Attribute values must not
+     * be null; string and binary type attributes must have lengths greater than zero;
+     * and set type attributes must not be empty. Requests that contain empty values
+     * are rejected with a <code>ValidationException</code> exception.</p> <p>If you
+     * specify any attributes that are part of an index key, then the data types for
+     * those attributes must match those of the schema in the table's attribute
+     * definition.</p> </li> </ul> </li> </ul>
+     */
+    inline BatchWriteItemRequest& AddRequestItems(Aws::String&& key, Aws::Vector<WriteRequest>&& value) { m_requestItemsHasBeenSet = true; m_requestItems.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>A map of one or more table names and, for each table, a list of operations to
+     * be performed (<code>DeleteRequest</code> or <code>PutRequest</code>). Each
+     * element in the map consists of the following:</p> <ul> <li> <p>
+     * <code>DeleteRequest</code> - Perform a <code>DeleteItem</code> operation on the
+     * specified item. The item to be deleted is identified by a <code>Key</code>
+     * subelement:</p> <ul> <li> <p> <code>Key</code> - A map of primary key attribute
+     * values that uniquely identify the item. Each entry in this map consists of an
+     * attribute name and an attribute value. For each primary key, you must provide
+     * <i>all</i> of the key attributes. For example, with a simple primary key, you
+     * only need to provide a value for the partition key. For a composite primary key,
+     * you must provide values for <i>both</i> the partition key and the sort key.</p>
+     * </li> </ul> </li> <li> <p> <code>PutRequest</code> - Perform a
+     * <code>PutItem</code> operation on the specified item. The item to be put is
+     * identified by an <code>Item</code> subelement:</p> <ul> <li> <p>
+     * <code>Item</code> - A map of attributes and their values. Each entry in this map
+     * consists of an attribute name and an attribute value. Attribute values must not
+     * be null; string and binary type attributes must have lengths greater than zero;
+     * and set type attributes must not be empty. Requests that contain empty values
+     * are rejected with a <code>ValidationException</code> exception.</p> <p>If you
+     * specify any attributes that are part of an index key, then the data types for
+     * those attributes must match those of the schema in the table's attribute
+     * definition.</p> </li> </ul> </li> </ul>
+     */
+    inline BatchWriteItemRequest& AddRequestItems(const char* key, Aws::Vector<WriteRequest>&& value) { m_requestItemsHasBeenSet = true; m_requestItems.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A map of one or more table names and, for each table, a list of operations to
+     * be performed (<code>DeleteRequest</code> or <code>PutRequest</code>). Each
+     * element in the map consists of the following:</p> <ul> <li> <p>
+     * <code>DeleteRequest</code> - Perform a <code>DeleteItem</code> operation on the
+     * specified item. The item to be deleted is identified by a <code>Key</code>
+     * subelement:</p> <ul> <li> <p> <code>Key</code> - A map of primary key attribute
+     * values that uniquely identify the item. Each entry in this map consists of an
+     * attribute name and an attribute value. For each primary key, you must provide
+     * <i>all</i> of the key attributes. For example, with a simple primary key, you
+     * only need to provide a value for the partition key. For a composite primary key,
+     * you must provide values for <i>both</i> the partition key and the sort key.</p>
+     * </li> </ul> </li> <li> <p> <code>PutRequest</code> - Perform a
+     * <code>PutItem</code> operation on the specified item. The item to be put is
+     * identified by an <code>Item</code> subelement:</p> <ul> <li> <p>
+     * <code>Item</code> - A map of attributes and their values. Each entry in this map
+     * consists of an attribute name and an attribute value. Attribute values must not
+     * be null; string and binary type attributes must have lengths greater than zero;
+     * and set type attributes must not be empty. Requests that contain empty values
+     * are rejected with a <code>ValidationException</code> exception.</p> <p>If you
+     * specify any attributes that are part of an index key, then the data types for
+     * those attributes must match those of the schema in the table's attribute
+     * definition.</p> </li> </ul> </li> </ul>
+     */
+    inline BatchWriteItemRequest& AddRequestItems(const char* key, const Aws::Vector<WriteRequest>& value) { m_requestItemsHasBeenSet = true; m_requestItems.emplace(key, value); return *this; }
+
+
+    
+    inline const ReturnConsumedCapacity& GetReturnConsumedCapacity() const{ return m_returnConsumedCapacity; }
+
+    
+    inline bool ReturnConsumedCapacityHasBeenSet() const { return m_returnConsumedCapacityHasBeenSet; }
+
+    
+    inline void SetReturnConsumedCapacity(const ReturnConsumedCapacity& value) { m_returnConsumedCapacityHasBeenSet = true; m_returnConsumedCapacity = value; }
+
+    
+    inline void SetReturnConsumedCapacity(ReturnConsumedCapacity&& value) { m_returnConsumedCapacityHasBeenSet = true; m_returnConsumedCapacity = std::move(value); }
+
+    
+    inline BatchWriteItemRequest& WithReturnConsumedCapacity(const ReturnConsumedCapacity& value) { SetReturnConsumedCapacity(value); return *this;}
+
+    
+    inline BatchWriteItemRequest& WithReturnConsumedCapacity(ReturnConsumedCapacity&& value) { SetReturnConsumedCapacity(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Determines whether item collection metrics are returned. If set to
+     * <code>SIZE</code>, the response includes statistics about item collections, if
+     * any, that were modified during the operation are returned in the response. If
+     * set to <code>NONE</code> (the default), no statistics are returned.</p>
+     */
+    inline const ReturnItemCollectionMetrics& GetReturnItemCollectionMetrics() const{ return m_returnItemCollectionMetrics; }
+
+    /**
+     * <p>Determines whether item collection metrics are returned. If set to
+     * <code>SIZE</code>, the response includes statistics about item collections, if
+     * any, that were modified during the operation are returned in the response. If
+     * set to <code>NONE</code> (the default), no statistics are returned.</p>
+     */
+    inline bool ReturnItemCollectionMetricsHasBeenSet() const { return m_returnItemCollectionMetricsHasBeenSet; }
+
+    /**
+     * <p>Determines whether item collection metrics are returned. If set to
+     * <code>SIZE</code>, the response includes statistics about item collections, if
+     * any, that were modified during the operation are returned in the response. If
+     * set to <code>NONE</code> (the default), no statistics are returned.</p>
+     */
+    inline void SetReturnItemCollectionMetrics(const ReturnItemCollectionMetrics& value) { m_returnItemCollectionMetricsHasBeenSet = true; m_returnItemCollectionMetrics = value; }
+
+    /**
+     * <p>Determines whether item collection metrics are returned. If set to
+     * <code>SIZE</code>, the response includes statistics about item collections, if
+     * any, that were modified during the operation are returned in the response. If
+     * set to <code>NONE</code> (the default), no statistics are returned.</p>
+     */
+    inline void SetReturnItemCollectionMetrics(ReturnItemCollectionMetrics&& value) { m_returnItemCollectionMetricsHasBeenSet = true; m_returnItemCollectionMetrics = std::move(value); }
+
+    /**
+     * <p>Determines whether item collection metrics are returned. If set to
+     * <code>SIZE</code>, the response includes statistics about item collections, if
+     * any, that were modified during the operation are returned in the response. If
+     * set to <code>NONE</code> (the default), no statistics are returned.</p>
+     */
+    inline BatchWriteItemRequest& WithReturnItemCollectionMetrics(const ReturnItemCollectionMetrics& value) { SetReturnItemCollectionMetrics(value); return *this;}
+
+    /**
+     * <p>Determines whether item collection metrics are returned. If set to
+     * <code>SIZE</code>, the response includes statistics about item collections, if
+     * any, that were modified during the operation are returned in the response. If
+     * set to <code>NONE</code> (the default), no statistics are returned.</p>
+     */
+    inline BatchWriteItemRequest& WithReturnItemCollectionMetrics(ReturnItemCollectionMetrics&& value) { SetReturnItemCollectionMetrics(std::move(value)); return *this;}
+
+  private:
+
+    Aws::Map<Aws::String, Aws::Vector<WriteRequest>> m_requestItems;
+    bool m_requestItemsHasBeenSet;
+
+    ReturnConsumedCapacity m_returnConsumedCapacity;
+    bool m_returnConsumedCapacityHasBeenSet;
+
+    ReturnItemCollectionMetrics m_returnItemCollectionMetrics;
+    bool m_returnItemCollectionMetricsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/BatchWriteItemResult.h

@@ -0,0 +1,628 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/dynamodb/model/ConsumedCapacity.h>
+#include <aws/dynamodb/model/WriteRequest.h>
+#include <aws/dynamodb/model/ItemCollectionMetrics.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+  /**
+   * <p>Represents the output of a <code>BatchWriteItem</code>
+   * operation.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/BatchWriteItemOutput">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API BatchWriteItemResult
+  {
+  public:
+    BatchWriteItemResult();
+    BatchWriteItemResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    BatchWriteItemResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>A map of tables and requests against those tables that were not processed.
+     * The <code>UnprocessedItems</code> value is in the same form as
+     * <code>RequestItems</code>, so you can provide this value directly to a
+     * subsequent <code>BatchGetItem</code> operation. For more information, see
+     * <code>RequestItems</code> in the Request Parameters section.</p> <p>Each
+     * <code>UnprocessedItems</code> entry consists of a table name and, for that
+     * table, a list of operations to perform (<code>DeleteRequest</code> or
+     * <code>PutRequest</code>).</p> <ul> <li> <p> <code>DeleteRequest</code> - Perform
+     * a <code>DeleteItem</code> operation on the specified item. The item to be
+     * deleted is identified by a <code>Key</code> subelement:</p> <ul> <li> <p>
+     * <code>Key</code> - A map of primary key attribute values that uniquely identify
+     * the item. Each entry in this map consists of an attribute name and an attribute
+     * value.</p> </li> </ul> </li> <li> <p> <code>PutRequest</code> - Perform a
+     * <code>PutItem</code> operation on the specified item. The item to be put is
+     * identified by an <code>Item</code> subelement:</p> <ul> <li> <p>
+     * <code>Item</code> - A map of attributes and their values. Each entry in this map
+     * consists of an attribute name and an attribute value. Attribute values must not
+     * be null; string and binary type attributes must have lengths greater than zero;
+     * and set type attributes must not be empty. Requests that contain empty values
+     * will be rejected with a <code>ValidationException</code> exception.</p> <p>If
+     * you specify any attributes that are part of an index key, then the data types
+     * for those attributes must match those of the schema in the table's attribute
+     * definition.</p> </li> </ul> </li> </ul> <p>If there are no unprocessed items
+     * remaining, the response contains an empty <code>UnprocessedItems</code> map.</p>
+     */
+    inline const Aws::Map<Aws::String, Aws::Vector<WriteRequest>>& GetUnprocessedItems() const{ return m_unprocessedItems; }
+
+    /**
+     * <p>A map of tables and requests against those tables that were not processed.
+     * The <code>UnprocessedItems</code> value is in the same form as
+     * <code>RequestItems</code>, so you can provide this value directly to a
+     * subsequent <code>BatchGetItem</code> operation. For more information, see
+     * <code>RequestItems</code> in the Request Parameters section.</p> <p>Each
+     * <code>UnprocessedItems</code> entry consists of a table name and, for that
+     * table, a list of operations to perform (<code>DeleteRequest</code> or
+     * <code>PutRequest</code>).</p> <ul> <li> <p> <code>DeleteRequest</code> - Perform
+     * a <code>DeleteItem</code> operation on the specified item. The item to be
+     * deleted is identified by a <code>Key</code> subelement:</p> <ul> <li> <p>
+     * <code>Key</code> - A map of primary key attribute values that uniquely identify
+     * the item. Each entry in this map consists of an attribute name and an attribute
+     * value.</p> </li> </ul> </li> <li> <p> <code>PutRequest</code> - Perform a
+     * <code>PutItem</code> operation on the specified item. The item to be put is
+     * identified by an <code>Item</code> subelement:</p> <ul> <li> <p>
+     * <code>Item</code> - A map of attributes and their values. Each entry in this map
+     * consists of an attribute name and an attribute value. Attribute values must not
+     * be null; string and binary type attributes must have lengths greater than zero;
+     * and set type attributes must not be empty. Requests that contain empty values
+     * will be rejected with a <code>ValidationException</code> exception.</p> <p>If
+     * you specify any attributes that are part of an index key, then the data types
+     * for those attributes must match those of the schema in the table's attribute
+     * definition.</p> </li> </ul> </li> </ul> <p>If there are no unprocessed items
+     * remaining, the response contains an empty <code>UnprocessedItems</code> map.</p>
+     */
+    inline void SetUnprocessedItems(const Aws::Map<Aws::String, Aws::Vector<WriteRequest>>& value) { m_unprocessedItems = value; }
+
+    /**
+     * <p>A map of tables and requests against those tables that were not processed.
+     * The <code>UnprocessedItems</code> value is in the same form as
+     * <code>RequestItems</code>, so you can provide this value directly to a
+     * subsequent <code>BatchGetItem</code> operation. For more information, see
+     * <code>RequestItems</code> in the Request Parameters section.</p> <p>Each
+     * <code>UnprocessedItems</code> entry consists of a table name and, for that
+     * table, a list of operations to perform (<code>DeleteRequest</code> or
+     * <code>PutRequest</code>).</p> <ul> <li> <p> <code>DeleteRequest</code> - Perform
+     * a <code>DeleteItem</code> operation on the specified item. The item to be
+     * deleted is identified by a <code>Key</code> subelement:</p> <ul> <li> <p>
+     * <code>Key</code> - A map of primary key attribute values that uniquely identify
+     * the item. Each entry in this map consists of an attribute name and an attribute
+     * value.</p> </li> </ul> </li> <li> <p> <code>PutRequest</code> - Perform a
+     * <code>PutItem</code> operation on the specified item. The item to be put is
+     * identified by an <code>Item</code> subelement:</p> <ul> <li> <p>
+     * <code>Item</code> - A map of attributes and their values. Each entry in this map
+     * consists of an attribute name and an attribute value. Attribute values must not
+     * be null; string and binary type attributes must have lengths greater than zero;
+     * and set type attributes must not be empty. Requests that contain empty values
+     * will be rejected with a <code>ValidationException</code> exception.</p> <p>If
+     * you specify any attributes that are part of an index key, then the data types
+     * for those attributes must match those of the schema in the table's attribute
+     * definition.</p> </li> </ul> </li> </ul> <p>If there are no unprocessed items
+     * remaining, the response contains an empty <code>UnprocessedItems</code> map.</p>
+     */
+    inline void SetUnprocessedItems(Aws::Map<Aws::String, Aws::Vector<WriteRequest>>&& value) { m_unprocessedItems = std::move(value); }
+
+    /**
+     * <p>A map of tables and requests against those tables that were not processed.
+     * The <code>UnprocessedItems</code> value is in the same form as
+     * <code>RequestItems</code>, so you can provide this value directly to a
+     * subsequent <code>BatchGetItem</code> operation. For more information, see
+     * <code>RequestItems</code> in the Request Parameters section.</p> <p>Each
+     * <code>UnprocessedItems</code> entry consists of a table name and, for that
+     * table, a list of operations to perform (<code>DeleteRequest</code> or
+     * <code>PutRequest</code>).</p> <ul> <li> <p> <code>DeleteRequest</code> - Perform
+     * a <code>DeleteItem</code> operation on the specified item. The item to be
+     * deleted is identified by a <code>Key</code> subelement:</p> <ul> <li> <p>
+     * <code>Key</code> - A map of primary key attribute values that uniquely identify
+     * the item. Each entry in this map consists of an attribute name and an attribute
+     * value.</p> </li> </ul> </li> <li> <p> <code>PutRequest</code> - Perform a
+     * <code>PutItem</code> operation on the specified item. The item to be put is
+     * identified by an <code>Item</code> subelement:</p> <ul> <li> <p>
+     * <code>Item</code> - A map of attributes and their values. Each entry in this map
+     * consists of an attribute name and an attribute value. Attribute values must not
+     * be null; string and binary type attributes must have lengths greater than zero;
+     * and set type attributes must not be empty. Requests that contain empty values
+     * will be rejected with a <code>ValidationException</code> exception.</p> <p>If
+     * you specify any attributes that are part of an index key, then the data types
+     * for those attributes must match those of the schema in the table's attribute
+     * definition.</p> </li> </ul> </li> </ul> <p>If there are no unprocessed items
+     * remaining, the response contains an empty <code>UnprocessedItems</code> map.</p>
+     */
+    inline BatchWriteItemResult& WithUnprocessedItems(const Aws::Map<Aws::String, Aws::Vector<WriteRequest>>& value) { SetUnprocessedItems(value); return *this;}
+
+    /**
+     * <p>A map of tables and requests against those tables that were not processed.
+     * The <code>UnprocessedItems</code> value is in the same form as
+     * <code>RequestItems</code>, so you can provide this value directly to a
+     * subsequent <code>BatchGetItem</code> operation. For more information, see
+     * <code>RequestItems</code> in the Request Parameters section.</p> <p>Each
+     * <code>UnprocessedItems</code> entry consists of a table name and, for that
+     * table, a list of operations to perform (<code>DeleteRequest</code> or
+     * <code>PutRequest</code>).</p> <ul> <li> <p> <code>DeleteRequest</code> - Perform
+     * a <code>DeleteItem</code> operation on the specified item. The item to be
+     * deleted is identified by a <code>Key</code> subelement:</p> <ul> <li> <p>
+     * <code>Key</code> - A map of primary key attribute values that uniquely identify
+     * the item. Each entry in this map consists of an attribute name and an attribute
+     * value.</p> </li> </ul> </li> <li> <p> <code>PutRequest</code> - Perform a
+     * <code>PutItem</code> operation on the specified item. The item to be put is
+     * identified by an <code>Item</code> subelement:</p> <ul> <li> <p>
+     * <code>Item</code> - A map of attributes and their values. Each entry in this map
+     * consists of an attribute name and an attribute value. Attribute values must not
+     * be null; string and binary type attributes must have lengths greater than zero;
+     * and set type attributes must not be empty. Requests that contain empty values
+     * will be rejected with a <code>ValidationException</code> exception.</p> <p>If
+     * you specify any attributes that are part of an index key, then the data types
+     * for those attributes must match those of the schema in the table's attribute
+     * definition.</p> </li> </ul> </li> </ul> <p>If there are no unprocessed items
+     * remaining, the response contains an empty <code>UnprocessedItems</code> map.</p>
+     */
+    inline BatchWriteItemResult& WithUnprocessedItems(Aws::Map<Aws::String, Aws::Vector<WriteRequest>>&& value) { SetUnprocessedItems(std::move(value)); return *this;}
+
+    /**
+     * <p>A map of tables and requests against those tables that were not processed.
+     * The <code>UnprocessedItems</code> value is in the same form as
+     * <code>RequestItems</code>, so you can provide this value directly to a
+     * subsequent <code>BatchGetItem</code> operation. For more information, see
+     * <code>RequestItems</code> in the Request Parameters section.</p> <p>Each
+     * <code>UnprocessedItems</code> entry consists of a table name and, for that
+     * table, a list of operations to perform (<code>DeleteRequest</code> or
+     * <code>PutRequest</code>).</p> <ul> <li> <p> <code>DeleteRequest</code> - Perform
+     * a <code>DeleteItem</code> operation on the specified item. The item to be
+     * deleted is identified by a <code>Key</code> subelement:</p> <ul> <li> <p>
+     * <code>Key</code> - A map of primary key attribute values that uniquely identify
+     * the item. Each entry in this map consists of an attribute name and an attribute
+     * value.</p> </li> </ul> </li> <li> <p> <code>PutRequest</code> - Perform a
+     * <code>PutItem</code> operation on the specified item. The item to be put is
+     * identified by an <code>Item</code> subelement:</p> <ul> <li> <p>
+     * <code>Item</code> - A map of attributes and their values. Each entry in this map
+     * consists of an attribute name and an attribute value. Attribute values must not
+     * be null; string and binary type attributes must have lengths greater than zero;
+     * and set type attributes must not be empty. Requests that contain empty values
+     * will be rejected with a <code>ValidationException</code> exception.</p> <p>If
+     * you specify any attributes that are part of an index key, then the data types
+     * for those attributes must match those of the schema in the table's attribute
+     * definition.</p> </li> </ul> </li> </ul> <p>If there are no unprocessed items
+     * remaining, the response contains an empty <code>UnprocessedItems</code> map.</p>
+     */
+    inline BatchWriteItemResult& AddUnprocessedItems(const Aws::String& key, const Aws::Vector<WriteRequest>& value) { m_unprocessedItems.emplace(key, value); return *this; }
+
+    /**
+     * <p>A map of tables and requests against those tables that were not processed.
+     * The <code>UnprocessedItems</code> value is in the same form as
+     * <code>RequestItems</code>, so you can provide this value directly to a
+     * subsequent <code>BatchGetItem</code> operation. For more information, see
+     * <code>RequestItems</code> in the Request Parameters section.</p> <p>Each
+     * <code>UnprocessedItems</code> entry consists of a table name and, for that
+     * table, a list of operations to perform (<code>DeleteRequest</code> or
+     * <code>PutRequest</code>).</p> <ul> <li> <p> <code>DeleteRequest</code> - Perform
+     * a <code>DeleteItem</code> operation on the specified item. The item to be
+     * deleted is identified by a <code>Key</code> subelement:</p> <ul> <li> <p>
+     * <code>Key</code> - A map of primary key attribute values that uniquely identify
+     * the item. Each entry in this map consists of an attribute name and an attribute
+     * value.</p> </li> </ul> </li> <li> <p> <code>PutRequest</code> - Perform a
+     * <code>PutItem</code> operation on the specified item. The item to be put is
+     * identified by an <code>Item</code> subelement:</p> <ul> <li> <p>
+     * <code>Item</code> - A map of attributes and their values. Each entry in this map
+     * consists of an attribute name and an attribute value. Attribute values must not
+     * be null; string and binary type attributes must have lengths greater than zero;
+     * and set type attributes must not be empty. Requests that contain empty values
+     * will be rejected with a <code>ValidationException</code> exception.</p> <p>If
+     * you specify any attributes that are part of an index key, then the data types
+     * for those attributes must match those of the schema in the table's attribute
+     * definition.</p> </li> </ul> </li> </ul> <p>If there are no unprocessed items
+     * remaining, the response contains an empty <code>UnprocessedItems</code> map.</p>
+     */
+    inline BatchWriteItemResult& AddUnprocessedItems(Aws::String&& key, const Aws::Vector<WriteRequest>& value) { m_unprocessedItems.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>A map of tables and requests against those tables that were not processed.
+     * The <code>UnprocessedItems</code> value is in the same form as
+     * <code>RequestItems</code>, so you can provide this value directly to a
+     * subsequent <code>BatchGetItem</code> operation. For more information, see
+     * <code>RequestItems</code> in the Request Parameters section.</p> <p>Each
+     * <code>UnprocessedItems</code> entry consists of a table name and, for that
+     * table, a list of operations to perform (<code>DeleteRequest</code> or
+     * <code>PutRequest</code>).</p> <ul> <li> <p> <code>DeleteRequest</code> - Perform
+     * a <code>DeleteItem</code> operation on the specified item. The item to be
+     * deleted is identified by a <code>Key</code> subelement:</p> <ul> <li> <p>
+     * <code>Key</code> - A map of primary key attribute values that uniquely identify
+     * the item. Each entry in this map consists of an attribute name and an attribute
+     * value.</p> </li> </ul> </li> <li> <p> <code>PutRequest</code> - Perform a
+     * <code>PutItem</code> operation on the specified item. The item to be put is
+     * identified by an <code>Item</code> subelement:</p> <ul> <li> <p>
+     * <code>Item</code> - A map of attributes and their values. Each entry in this map
+     * consists of an attribute name and an attribute value. Attribute values must not
+     * be null; string and binary type attributes must have lengths greater than zero;
+     * and set type attributes must not be empty. Requests that contain empty values
+     * will be rejected with a <code>ValidationException</code> exception.</p> <p>If
+     * you specify any attributes that are part of an index key, then the data types
+     * for those attributes must match those of the schema in the table's attribute
+     * definition.</p> </li> </ul> </li> </ul> <p>If there are no unprocessed items
+     * remaining, the response contains an empty <code>UnprocessedItems</code> map.</p>
+     */
+    inline BatchWriteItemResult& AddUnprocessedItems(const Aws::String& key, Aws::Vector<WriteRequest>&& value) { m_unprocessedItems.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A map of tables and requests against those tables that were not processed.
+     * The <code>UnprocessedItems</code> value is in the same form as
+     * <code>RequestItems</code>, so you can provide this value directly to a
+     * subsequent <code>BatchGetItem</code> operation. For more information, see
+     * <code>RequestItems</code> in the Request Parameters section.</p> <p>Each
+     * <code>UnprocessedItems</code> entry consists of a table name and, for that
+     * table, a list of operations to perform (<code>DeleteRequest</code> or
+     * <code>PutRequest</code>).</p> <ul> <li> <p> <code>DeleteRequest</code> - Perform
+     * a <code>DeleteItem</code> operation on the specified item. The item to be
+     * deleted is identified by a <code>Key</code> subelement:</p> <ul> <li> <p>
+     * <code>Key</code> - A map of primary key attribute values that uniquely identify
+     * the item. Each entry in this map consists of an attribute name and an attribute
+     * value.</p> </li> </ul> </li> <li> <p> <code>PutRequest</code> - Perform a
+     * <code>PutItem</code> operation on the specified item. The item to be put is
+     * identified by an <code>Item</code> subelement:</p> <ul> <li> <p>
+     * <code>Item</code> - A map of attributes and their values. Each entry in this map
+     * consists of an attribute name and an attribute value. Attribute values must not
+     * be null; string and binary type attributes must have lengths greater than zero;
+     * and set type attributes must not be empty. Requests that contain empty values
+     * will be rejected with a <code>ValidationException</code> exception.</p> <p>If
+     * you specify any attributes that are part of an index key, then the data types
+     * for those attributes must match those of the schema in the table's attribute
+     * definition.</p> </li> </ul> </li> </ul> <p>If there are no unprocessed items
+     * remaining, the response contains an empty <code>UnprocessedItems</code> map.</p>
+     */
+    inline BatchWriteItemResult& AddUnprocessedItems(Aws::String&& key, Aws::Vector<WriteRequest>&& value) { m_unprocessedItems.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>A map of tables and requests against those tables that were not processed.
+     * The <code>UnprocessedItems</code> value is in the same form as
+     * <code>RequestItems</code>, so you can provide this value directly to a
+     * subsequent <code>BatchGetItem</code> operation. For more information, see
+     * <code>RequestItems</code> in the Request Parameters section.</p> <p>Each
+     * <code>UnprocessedItems</code> entry consists of a table name and, for that
+     * table, a list of operations to perform (<code>DeleteRequest</code> or
+     * <code>PutRequest</code>).</p> <ul> <li> <p> <code>DeleteRequest</code> - Perform
+     * a <code>DeleteItem</code> operation on the specified item. The item to be
+     * deleted is identified by a <code>Key</code> subelement:</p> <ul> <li> <p>
+     * <code>Key</code> - A map of primary key attribute values that uniquely identify
+     * the item. Each entry in this map consists of an attribute name and an attribute
+     * value.</p> </li> </ul> </li> <li> <p> <code>PutRequest</code> - Perform a
+     * <code>PutItem</code> operation on the specified item. The item to be put is
+     * identified by an <code>Item</code> subelement:</p> <ul> <li> <p>
+     * <code>Item</code> - A map of attributes and their values. Each entry in this map
+     * consists of an attribute name and an attribute value. Attribute values must not
+     * be null; string and binary type attributes must have lengths greater than zero;
+     * and set type attributes must not be empty. Requests that contain empty values
+     * will be rejected with a <code>ValidationException</code> exception.</p> <p>If
+     * you specify any attributes that are part of an index key, then the data types
+     * for those attributes must match those of the schema in the table's attribute
+     * definition.</p> </li> </ul> </li> </ul> <p>If there are no unprocessed items
+     * remaining, the response contains an empty <code>UnprocessedItems</code> map.</p>
+     */
+    inline BatchWriteItemResult& AddUnprocessedItems(const char* key, Aws::Vector<WriteRequest>&& value) { m_unprocessedItems.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A map of tables and requests against those tables that were not processed.
+     * The <code>UnprocessedItems</code> value is in the same form as
+     * <code>RequestItems</code>, so you can provide this value directly to a
+     * subsequent <code>BatchGetItem</code> operation. For more information, see
+     * <code>RequestItems</code> in the Request Parameters section.</p> <p>Each
+     * <code>UnprocessedItems</code> entry consists of a table name and, for that
+     * table, a list of operations to perform (<code>DeleteRequest</code> or
+     * <code>PutRequest</code>).</p> <ul> <li> <p> <code>DeleteRequest</code> - Perform
+     * a <code>DeleteItem</code> operation on the specified item. The item to be
+     * deleted is identified by a <code>Key</code> subelement:</p> <ul> <li> <p>
+     * <code>Key</code> - A map of primary key attribute values that uniquely identify
+     * the item. Each entry in this map consists of an attribute name and an attribute
+     * value.</p> </li> </ul> </li> <li> <p> <code>PutRequest</code> - Perform a
+     * <code>PutItem</code> operation on the specified item. The item to be put is
+     * identified by an <code>Item</code> subelement:</p> <ul> <li> <p>
+     * <code>Item</code> - A map of attributes and their values. Each entry in this map
+     * consists of an attribute name and an attribute value. Attribute values must not
+     * be null; string and binary type attributes must have lengths greater than zero;
+     * and set type attributes must not be empty. Requests that contain empty values
+     * will be rejected with a <code>ValidationException</code> exception.</p> <p>If
+     * you specify any attributes that are part of an index key, then the data types
+     * for those attributes must match those of the schema in the table's attribute
+     * definition.</p> </li> </ul> </li> </ul> <p>If there are no unprocessed items
+     * remaining, the response contains an empty <code>UnprocessedItems</code> map.</p>
+     */
+    inline BatchWriteItemResult& AddUnprocessedItems(const char* key, const Aws::Vector<WriteRequest>& value) { m_unprocessedItems.emplace(key, value); return *this; }
+
+
+    /**
+     * <p>A list of tables that were processed by <code>BatchWriteItem</code> and, for
+     * each table, information about any item collections that were affected by
+     * individual <code>DeleteItem</code> or <code>PutItem</code> operations.</p>
+     * <p>Each entry consists of the following subelements:</p> <ul> <li> <p>
+     * <code>ItemCollectionKey</code> - The partition key value of the item collection.
+     * This is the same as the partition key value of the item.</p> </li> <li> <p>
+     * <code>SizeEstimateRangeGB</code> - An estimate of item collection size,
+     * expressed in GB. This is a two-element array containing a lower bound and an
+     * upper bound for the estimate. The estimate includes the size of all the items in
+     * the table, plus the size of all attributes projected into all of the local
+     * secondary indexes on the table. Use this estimate to measure whether a local
+     * secondary index is approaching its size limit.</p> <p>The estimate is subject to
+     * change over time; therefore, do not rely on the precision or accuracy of the
+     * estimate.</p> </li> </ul>
+     */
+    inline const Aws::Map<Aws::String, Aws::Vector<ItemCollectionMetrics>>& GetItemCollectionMetrics() const{ return m_itemCollectionMetrics; }
+
+    /**
+     * <p>A list of tables that were processed by <code>BatchWriteItem</code> and, for
+     * each table, information about any item collections that were affected by
+     * individual <code>DeleteItem</code> or <code>PutItem</code> operations.</p>
+     * <p>Each entry consists of the following subelements:</p> <ul> <li> <p>
+     * <code>ItemCollectionKey</code> - The partition key value of the item collection.
+     * This is the same as the partition key value of the item.</p> </li> <li> <p>
+     * <code>SizeEstimateRangeGB</code> - An estimate of item collection size,
+     * expressed in GB. This is a two-element array containing a lower bound and an
+     * upper bound for the estimate. The estimate includes the size of all the items in
+     * the table, plus the size of all attributes projected into all of the local
+     * secondary indexes on the table. Use this estimate to measure whether a local
+     * secondary index is approaching its size limit.</p> <p>The estimate is subject to
+     * change over time; therefore, do not rely on the precision or accuracy of the
+     * estimate.</p> </li> </ul>
+     */
+    inline void SetItemCollectionMetrics(const Aws::Map<Aws::String, Aws::Vector<ItemCollectionMetrics>>& value) { m_itemCollectionMetrics = value; }
+
+    /**
+     * <p>A list of tables that were processed by <code>BatchWriteItem</code> and, for
+     * each table, information about any item collections that were affected by
+     * individual <code>DeleteItem</code> or <code>PutItem</code> operations.</p>
+     * <p>Each entry consists of the following subelements:</p> <ul> <li> <p>
+     * <code>ItemCollectionKey</code> - The partition key value of the item collection.
+     * This is the same as the partition key value of the item.</p> </li> <li> <p>
+     * <code>SizeEstimateRangeGB</code> - An estimate of item collection size,
+     * expressed in GB. This is a two-element array containing a lower bound and an
+     * upper bound for the estimate. The estimate includes the size of all the items in
+     * the table, plus the size of all attributes projected into all of the local
+     * secondary indexes on the table. Use this estimate to measure whether a local
+     * secondary index is approaching its size limit.</p> <p>The estimate is subject to
+     * change over time; therefore, do not rely on the precision or accuracy of the
+     * estimate.</p> </li> </ul>
+     */
+    inline void SetItemCollectionMetrics(Aws::Map<Aws::String, Aws::Vector<ItemCollectionMetrics>>&& value) { m_itemCollectionMetrics = std::move(value); }
+
+    /**
+     * <p>A list of tables that were processed by <code>BatchWriteItem</code> and, for
+     * each table, information about any item collections that were affected by
+     * individual <code>DeleteItem</code> or <code>PutItem</code> operations.</p>
+     * <p>Each entry consists of the following subelements:</p> <ul> <li> <p>
+     * <code>ItemCollectionKey</code> - The partition key value of the item collection.
+     * This is the same as the partition key value of the item.</p> </li> <li> <p>
+     * <code>SizeEstimateRangeGB</code> - An estimate of item collection size,
+     * expressed in GB. This is a two-element array containing a lower bound and an
+     * upper bound for the estimate. The estimate includes the size of all the items in
+     * the table, plus the size of all attributes projected into all of the local
+     * secondary indexes on the table. Use this estimate to measure whether a local
+     * secondary index is approaching its size limit.</p> <p>The estimate is subject to
+     * change over time; therefore, do not rely on the precision or accuracy of the
+     * estimate.</p> </li> </ul>
+     */
+    inline BatchWriteItemResult& WithItemCollectionMetrics(const Aws::Map<Aws::String, Aws::Vector<ItemCollectionMetrics>>& value) { SetItemCollectionMetrics(value); return *this;}
+
+    /**
+     * <p>A list of tables that were processed by <code>BatchWriteItem</code> and, for
+     * each table, information about any item collections that were affected by
+     * individual <code>DeleteItem</code> or <code>PutItem</code> operations.</p>
+     * <p>Each entry consists of the following subelements:</p> <ul> <li> <p>
+     * <code>ItemCollectionKey</code> - The partition key value of the item collection.
+     * This is the same as the partition key value of the item.</p> </li> <li> <p>
+     * <code>SizeEstimateRangeGB</code> - An estimate of item collection size,
+     * expressed in GB. This is a two-element array containing a lower bound and an
+     * upper bound for the estimate. The estimate includes the size of all the items in
+     * the table, plus the size of all attributes projected into all of the local
+     * secondary indexes on the table. Use this estimate to measure whether a local
+     * secondary index is approaching its size limit.</p> <p>The estimate is subject to
+     * change over time; therefore, do not rely on the precision or accuracy of the
+     * estimate.</p> </li> </ul>
+     */
+    inline BatchWriteItemResult& WithItemCollectionMetrics(Aws::Map<Aws::String, Aws::Vector<ItemCollectionMetrics>>&& value) { SetItemCollectionMetrics(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of tables that were processed by <code>BatchWriteItem</code> and, for
+     * each table, information about any item collections that were affected by
+     * individual <code>DeleteItem</code> or <code>PutItem</code> operations.</p>
+     * <p>Each entry consists of the following subelements:</p> <ul> <li> <p>
+     * <code>ItemCollectionKey</code> - The partition key value of the item collection.
+     * This is the same as the partition key value of the item.</p> </li> <li> <p>
+     * <code>SizeEstimateRangeGB</code> - An estimate of item collection size,
+     * expressed in GB. This is a two-element array containing a lower bound and an
+     * upper bound for the estimate. The estimate includes the size of all the items in
+     * the table, plus the size of all attributes projected into all of the local
+     * secondary indexes on the table. Use this estimate to measure whether a local
+     * secondary index is approaching its size limit.</p> <p>The estimate is subject to
+     * change over time; therefore, do not rely on the precision or accuracy of the
+     * estimate.</p> </li> </ul>
+     */
+    inline BatchWriteItemResult& AddItemCollectionMetrics(const Aws::String& key, const Aws::Vector<ItemCollectionMetrics>& value) { m_itemCollectionMetrics.emplace(key, value); return *this; }
+
+    /**
+     * <p>A list of tables that were processed by <code>BatchWriteItem</code> and, for
+     * each table, information about any item collections that were affected by
+     * individual <code>DeleteItem</code> or <code>PutItem</code> operations.</p>
+     * <p>Each entry consists of the following subelements:</p> <ul> <li> <p>
+     * <code>ItemCollectionKey</code> - The partition key value of the item collection.
+     * This is the same as the partition key value of the item.</p> </li> <li> <p>
+     * <code>SizeEstimateRangeGB</code> - An estimate of item collection size,
+     * expressed in GB. This is a two-element array containing a lower bound and an
+     * upper bound for the estimate. The estimate includes the size of all the items in
+     * the table, plus the size of all attributes projected into all of the local
+     * secondary indexes on the table. Use this estimate to measure whether a local
+     * secondary index is approaching its size limit.</p> <p>The estimate is subject to
+     * change over time; therefore, do not rely on the precision or accuracy of the
+     * estimate.</p> </li> </ul>
+     */
+    inline BatchWriteItemResult& AddItemCollectionMetrics(Aws::String&& key, const Aws::Vector<ItemCollectionMetrics>& value) { m_itemCollectionMetrics.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>A list of tables that were processed by <code>BatchWriteItem</code> and, for
+     * each table, information about any item collections that were affected by
+     * individual <code>DeleteItem</code> or <code>PutItem</code> operations.</p>
+     * <p>Each entry consists of the following subelements:</p> <ul> <li> <p>
+     * <code>ItemCollectionKey</code> - The partition key value of the item collection.
+     * This is the same as the partition key value of the item.</p> </li> <li> <p>
+     * <code>SizeEstimateRangeGB</code> - An estimate of item collection size,
+     * expressed in GB. This is a two-element array containing a lower bound and an
+     * upper bound for the estimate. The estimate includes the size of all the items in
+     * the table, plus the size of all attributes projected into all of the local
+     * secondary indexes on the table. Use this estimate to measure whether a local
+     * secondary index is approaching its size limit.</p> <p>The estimate is subject to
+     * change over time; therefore, do not rely on the precision or accuracy of the
+     * estimate.</p> </li> </ul>
+     */
+    inline BatchWriteItemResult& AddItemCollectionMetrics(const Aws::String& key, Aws::Vector<ItemCollectionMetrics>&& value) { m_itemCollectionMetrics.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A list of tables that were processed by <code>BatchWriteItem</code> and, for
+     * each table, information about any item collections that were affected by
+     * individual <code>DeleteItem</code> or <code>PutItem</code> operations.</p>
+     * <p>Each entry consists of the following subelements:</p> <ul> <li> <p>
+     * <code>ItemCollectionKey</code> - The partition key value of the item collection.
+     * This is the same as the partition key value of the item.</p> </li> <li> <p>
+     * <code>SizeEstimateRangeGB</code> - An estimate of item collection size,
+     * expressed in GB. This is a two-element array containing a lower bound and an
+     * upper bound for the estimate. The estimate includes the size of all the items in
+     * the table, plus the size of all attributes projected into all of the local
+     * secondary indexes on the table. Use this estimate to measure whether a local
+     * secondary index is approaching its size limit.</p> <p>The estimate is subject to
+     * change over time; therefore, do not rely on the precision or accuracy of the
+     * estimate.</p> </li> </ul>
+     */
+    inline BatchWriteItemResult& AddItemCollectionMetrics(Aws::String&& key, Aws::Vector<ItemCollectionMetrics>&& value) { m_itemCollectionMetrics.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>A list of tables that were processed by <code>BatchWriteItem</code> and, for
+     * each table, information about any item collections that were affected by
+     * individual <code>DeleteItem</code> or <code>PutItem</code> operations.</p>
+     * <p>Each entry consists of the following subelements:</p> <ul> <li> <p>
+     * <code>ItemCollectionKey</code> - The partition key value of the item collection.
+     * This is the same as the partition key value of the item.</p> </li> <li> <p>
+     * <code>SizeEstimateRangeGB</code> - An estimate of item collection size,
+     * expressed in GB. This is a two-element array containing a lower bound and an
+     * upper bound for the estimate. The estimate includes the size of all the items in
+     * the table, plus the size of all attributes projected into all of the local
+     * secondary indexes on the table. Use this estimate to measure whether a local
+     * secondary index is approaching its size limit.</p> <p>The estimate is subject to
+     * change over time; therefore, do not rely on the precision or accuracy of the
+     * estimate.</p> </li> </ul>
+     */
+    inline BatchWriteItemResult& AddItemCollectionMetrics(const char* key, Aws::Vector<ItemCollectionMetrics>&& value) { m_itemCollectionMetrics.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A list of tables that were processed by <code>BatchWriteItem</code> and, for
+     * each table, information about any item collections that were affected by
+     * individual <code>DeleteItem</code> or <code>PutItem</code> operations.</p>
+     * <p>Each entry consists of the following subelements:</p> <ul> <li> <p>
+     * <code>ItemCollectionKey</code> - The partition key value of the item collection.
+     * This is the same as the partition key value of the item.</p> </li> <li> <p>
+     * <code>SizeEstimateRangeGB</code> - An estimate of item collection size,
+     * expressed in GB. This is a two-element array containing a lower bound and an
+     * upper bound for the estimate. The estimate includes the size of all the items in
+     * the table, plus the size of all attributes projected into all of the local
+     * secondary indexes on the table. Use this estimate to measure whether a local
+     * secondary index is approaching its size limit.</p> <p>The estimate is subject to
+     * change over time; therefore, do not rely on the precision or accuracy of the
+     * estimate.</p> </li> </ul>
+     */
+    inline BatchWriteItemResult& AddItemCollectionMetrics(const char* key, const Aws::Vector<ItemCollectionMetrics>& value) { m_itemCollectionMetrics.emplace(key, value); return *this; }
+
+
+    /**
+     * <p>The capacity units consumed by the entire <code>BatchWriteItem</code>
+     * operation.</p> <p>Each element consists of:</p> <ul> <li> <p>
+     * <code>TableName</code> - The table that consumed the provisioned throughput.</p>
+     * </li> <li> <p> <code>CapacityUnits</code> - The total number of capacity units
+     * consumed.</p> </li> </ul>
+     */
+    inline const Aws::Vector<ConsumedCapacity>& GetConsumedCapacity() const{ return m_consumedCapacity; }
+
+    /**
+     * <p>The capacity units consumed by the entire <code>BatchWriteItem</code>
+     * operation.</p> <p>Each element consists of:</p> <ul> <li> <p>
+     * <code>TableName</code> - The table that consumed the provisioned throughput.</p>
+     * </li> <li> <p> <code>CapacityUnits</code> - The total number of capacity units
+     * consumed.</p> </li> </ul>
+     */
+    inline void SetConsumedCapacity(const Aws::Vector<ConsumedCapacity>& value) { m_consumedCapacity = value; }
+
+    /**
+     * <p>The capacity units consumed by the entire <code>BatchWriteItem</code>
+     * operation.</p> <p>Each element consists of:</p> <ul> <li> <p>
+     * <code>TableName</code> - The table that consumed the provisioned throughput.</p>
+     * </li> <li> <p> <code>CapacityUnits</code> - The total number of capacity units
+     * consumed.</p> </li> </ul>
+     */
+    inline void SetConsumedCapacity(Aws::Vector<ConsumedCapacity>&& value) { m_consumedCapacity = std::move(value); }
+
+    /**
+     * <p>The capacity units consumed by the entire <code>BatchWriteItem</code>
+     * operation.</p> <p>Each element consists of:</p> <ul> <li> <p>
+     * <code>TableName</code> - The table that consumed the provisioned throughput.</p>
+     * </li> <li> <p> <code>CapacityUnits</code> - The total number of capacity units
+     * consumed.</p> </li> </ul>
+     */
+    inline BatchWriteItemResult& WithConsumedCapacity(const Aws::Vector<ConsumedCapacity>& value) { SetConsumedCapacity(value); return *this;}
+
+    /**
+     * <p>The capacity units consumed by the entire <code>BatchWriteItem</code>
+     * operation.</p> <p>Each element consists of:</p> <ul> <li> <p>
+     * <code>TableName</code> - The table that consumed the provisioned throughput.</p>
+     * </li> <li> <p> <code>CapacityUnits</code> - The total number of capacity units
+     * consumed.</p> </li> </ul>
+     */
+    inline BatchWriteItemResult& WithConsumedCapacity(Aws::Vector<ConsumedCapacity>&& value) { SetConsumedCapacity(std::move(value)); return *this;}
+
+    /**
+     * <p>The capacity units consumed by the entire <code>BatchWriteItem</code>
+     * operation.</p> <p>Each element consists of:</p> <ul> <li> <p>
+     * <code>TableName</code> - The table that consumed the provisioned throughput.</p>
+     * </li> <li> <p> <code>CapacityUnits</code> - The total number of capacity units
+     * consumed.</p> </li> </ul>
+     */
+    inline BatchWriteItemResult& AddConsumedCapacity(const ConsumedCapacity& value) { m_consumedCapacity.push_back(value); return *this; }
+
+    /**
+     * <p>The capacity units consumed by the entire <code>BatchWriteItem</code>
+     * operation.</p> <p>Each element consists of:</p> <ul> <li> <p>
+     * <code>TableName</code> - The table that consumed the provisioned throughput.</p>
+     * </li> <li> <p> <code>CapacityUnits</code> - The total number of capacity units
+     * consumed.</p> </li> </ul>
+     */
+    inline BatchWriteItemResult& AddConsumedCapacity(ConsumedCapacity&& value) { m_consumedCapacity.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::Map<Aws::String, Aws::Vector<WriteRequest>> m_unprocessedItems;
+
+    Aws::Map<Aws::String, Aws::Vector<ItemCollectionMetrics>> m_itemCollectionMetrics;
+
+    Aws::Vector<ConsumedCapacity> m_consumedCapacity;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/BillingMode.h

@@ -0,0 +1,31 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+  enum class BillingMode
+  {
+    NOT_SET,
+    PROVISIONED,
+    PAY_PER_REQUEST
+  };
+
+namespace BillingModeMapper
+{
+AWS_DYNAMODB_API BillingMode GetBillingModeForName(const Aws::String& name);
+
+AWS_DYNAMODB_API Aws::String GetNameForBillingMode(BillingMode value);
+} // namespace BillingModeMapper
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/BillingModeSummary.h

@@ -0,0 +1,156 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/model/BillingMode.h>
+#include <aws/core/utils/DateTime.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Contains the details for the read/write capacity mode.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/BillingModeSummary">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API BillingModeSummary
+  {
+  public:
+    BillingModeSummary();
+    BillingModeSummary(Aws::Utils::Json::JsonView jsonValue);
+    BillingModeSummary& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Controls how you are charged for read and write throughput and how you manage
+     * capacity. This setting can be changed later.</p> <ul> <li> <p>
+     * <code>PROVISIONED</code> - Sets the read/write capacity mode to
+     * <code>PROVISIONED</code>. We recommend using <code>PROVISIONED</code> for
+     * predictable workloads.</p> </li> <li> <p> <code>PAY_PER_REQUEST</code> - Sets
+     * the read/write capacity mode to <code>PAY_PER_REQUEST</code>. We recommend using
+     * <code>PAY_PER_REQUEST</code> for unpredictable workloads. </p> </li> </ul>
+     */
+    inline const BillingMode& GetBillingMode() const{ return m_billingMode; }
+
+    /**
+     * <p>Controls how you are charged for read and write throughput and how you manage
+     * capacity. This setting can be changed later.</p> <ul> <li> <p>
+     * <code>PROVISIONED</code> - Sets the read/write capacity mode to
+     * <code>PROVISIONED</code>. We recommend using <code>PROVISIONED</code> for
+     * predictable workloads.</p> </li> <li> <p> <code>PAY_PER_REQUEST</code> - Sets
+     * the read/write capacity mode to <code>PAY_PER_REQUEST</code>. We recommend using
+     * <code>PAY_PER_REQUEST</code> for unpredictable workloads. </p> </li> </ul>
+     */
+    inline bool BillingModeHasBeenSet() const { return m_billingModeHasBeenSet; }
+
+    /**
+     * <p>Controls how you are charged for read and write throughput and how you manage
+     * capacity. This setting can be changed later.</p> <ul> <li> <p>
+     * <code>PROVISIONED</code> - Sets the read/write capacity mode to
+     * <code>PROVISIONED</code>. We recommend using <code>PROVISIONED</code> for
+     * predictable workloads.</p> </li> <li> <p> <code>PAY_PER_REQUEST</code> - Sets
+     * the read/write capacity mode to <code>PAY_PER_REQUEST</code>. We recommend using
+     * <code>PAY_PER_REQUEST</code> for unpredictable workloads. </p> </li> </ul>
+     */
+    inline void SetBillingMode(const BillingMode& value) { m_billingModeHasBeenSet = true; m_billingMode = value; }
+
+    /**
+     * <p>Controls how you are charged for read and write throughput and how you manage
+     * capacity. This setting can be changed later.</p> <ul> <li> <p>
+     * <code>PROVISIONED</code> - Sets the read/write capacity mode to
+     * <code>PROVISIONED</code>. We recommend using <code>PROVISIONED</code> for
+     * predictable workloads.</p> </li> <li> <p> <code>PAY_PER_REQUEST</code> - Sets
+     * the read/write capacity mode to <code>PAY_PER_REQUEST</code>. We recommend using
+     * <code>PAY_PER_REQUEST</code> for unpredictable workloads. </p> </li> </ul>
+     */
+    inline void SetBillingMode(BillingMode&& value) { m_billingModeHasBeenSet = true; m_billingMode = std::move(value); }
+
+    /**
+     * <p>Controls how you are charged for read and write throughput and how you manage
+     * capacity. This setting can be changed later.</p> <ul> <li> <p>
+     * <code>PROVISIONED</code> - Sets the read/write capacity mode to
+     * <code>PROVISIONED</code>. We recommend using <code>PROVISIONED</code> for
+     * predictable workloads.</p> </li> <li> <p> <code>PAY_PER_REQUEST</code> - Sets
+     * the read/write capacity mode to <code>PAY_PER_REQUEST</code>. We recommend using
+     * <code>PAY_PER_REQUEST</code> for unpredictable workloads. </p> </li> </ul>
+     */
+    inline BillingModeSummary& WithBillingMode(const BillingMode& value) { SetBillingMode(value); return *this;}
+
+    /**
+     * <p>Controls how you are charged for read and write throughput and how you manage
+     * capacity. This setting can be changed later.</p> <ul> <li> <p>
+     * <code>PROVISIONED</code> - Sets the read/write capacity mode to
+     * <code>PROVISIONED</code>. We recommend using <code>PROVISIONED</code> for
+     * predictable workloads.</p> </li> <li> <p> <code>PAY_PER_REQUEST</code> - Sets
+     * the read/write capacity mode to <code>PAY_PER_REQUEST</code>. We recommend using
+     * <code>PAY_PER_REQUEST</code> for unpredictable workloads. </p> </li> </ul>
+     */
+    inline BillingModeSummary& WithBillingMode(BillingMode&& value) { SetBillingMode(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Represents the time when <code>PAY_PER_REQUEST</code> was last set as the
+     * read/write capacity mode.</p>
+     */
+    inline const Aws::Utils::DateTime& GetLastUpdateToPayPerRequestDateTime() const{ return m_lastUpdateToPayPerRequestDateTime; }
+
+    /**
+     * <p>Represents the time when <code>PAY_PER_REQUEST</code> was last set as the
+     * read/write capacity mode.</p>
+     */
+    inline bool LastUpdateToPayPerRequestDateTimeHasBeenSet() const { return m_lastUpdateToPayPerRequestDateTimeHasBeenSet; }
+
+    /**
+     * <p>Represents the time when <code>PAY_PER_REQUEST</code> was last set as the
+     * read/write capacity mode.</p>
+     */
+    inline void SetLastUpdateToPayPerRequestDateTime(const Aws::Utils::DateTime& value) { m_lastUpdateToPayPerRequestDateTimeHasBeenSet = true; m_lastUpdateToPayPerRequestDateTime = value; }
+
+    /**
+     * <p>Represents the time when <code>PAY_PER_REQUEST</code> was last set as the
+     * read/write capacity mode.</p>
+     */
+    inline void SetLastUpdateToPayPerRequestDateTime(Aws::Utils::DateTime&& value) { m_lastUpdateToPayPerRequestDateTimeHasBeenSet = true; m_lastUpdateToPayPerRequestDateTime = std::move(value); }
+
+    /**
+     * <p>Represents the time when <code>PAY_PER_REQUEST</code> was last set as the
+     * read/write capacity mode.</p>
+     */
+    inline BillingModeSummary& WithLastUpdateToPayPerRequestDateTime(const Aws::Utils::DateTime& value) { SetLastUpdateToPayPerRequestDateTime(value); return *this;}
+
+    /**
+     * <p>Represents the time when <code>PAY_PER_REQUEST</code> was last set as the
+     * read/write capacity mode.</p>
+     */
+    inline BillingModeSummary& WithLastUpdateToPayPerRequestDateTime(Aws::Utils::DateTime&& value) { SetLastUpdateToPayPerRequestDateTime(std::move(value)); return *this;}
+
+  private:
+
+    BillingMode m_billingMode;
+    bool m_billingModeHasBeenSet;
+
+    Aws::Utils::DateTime m_lastUpdateToPayPerRequestDateTime;
+    bool m_lastUpdateToPayPerRequestDateTimeHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/CancellationReason.h

@@ -0,0 +1,202 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/dynamodb/model/AttributeValue.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>An ordered list of errors for each item in the request which caused the
+   * transaction to get cancelled. The values of the list are ordered according to
+   * the ordering of the <code>TransactWriteItems</code> request parameter. If no
+   * error occurred for the associated item an error with a Null code and Null
+   * message will be present. </p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/CancellationReason">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API CancellationReason
+  {
+  public:
+    CancellationReason();
+    CancellationReason(Aws::Utils::Json::JsonView jsonValue);
+    CancellationReason& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Item in the request which caused the transaction to get cancelled.</p>
+     */
+    inline const Aws::Map<Aws::String, AttributeValue>& GetItem() const{ return m_item; }
+
+    /**
+     * <p>Item in the request which caused the transaction to get cancelled.</p>
+     */
+    inline bool ItemHasBeenSet() const { return m_itemHasBeenSet; }
+
+    /**
+     * <p>Item in the request which caused the transaction to get cancelled.</p>
+     */
+    inline void SetItem(const Aws::Map<Aws::String, AttributeValue>& value) { m_itemHasBeenSet = true; m_item = value; }
+
+    /**
+     * <p>Item in the request which caused the transaction to get cancelled.</p>
+     */
+    inline void SetItem(Aws::Map<Aws::String, AttributeValue>&& value) { m_itemHasBeenSet = true; m_item = std::move(value); }
+
+    /**
+     * <p>Item in the request which caused the transaction to get cancelled.</p>
+     */
+    inline CancellationReason& WithItem(const Aws::Map<Aws::String, AttributeValue>& value) { SetItem(value); return *this;}
+
+    /**
+     * <p>Item in the request which caused the transaction to get cancelled.</p>
+     */
+    inline CancellationReason& WithItem(Aws::Map<Aws::String, AttributeValue>&& value) { SetItem(std::move(value)); return *this;}
+
+    /**
+     * <p>Item in the request which caused the transaction to get cancelled.</p>
+     */
+    inline CancellationReason& AddItem(const Aws::String& key, const AttributeValue& value) { m_itemHasBeenSet = true; m_item.emplace(key, value); return *this; }
+
+    /**
+     * <p>Item in the request which caused the transaction to get cancelled.</p>
+     */
+    inline CancellationReason& AddItem(Aws::String&& key, const AttributeValue& value) { m_itemHasBeenSet = true; m_item.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>Item in the request which caused the transaction to get cancelled.</p>
+     */
+    inline CancellationReason& AddItem(const Aws::String& key, AttributeValue&& value) { m_itemHasBeenSet = true; m_item.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>Item in the request which caused the transaction to get cancelled.</p>
+     */
+    inline CancellationReason& AddItem(Aws::String&& key, AttributeValue&& value) { m_itemHasBeenSet = true; m_item.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>Item in the request which caused the transaction to get cancelled.</p>
+     */
+    inline CancellationReason& AddItem(const char* key, AttributeValue&& value) { m_itemHasBeenSet = true; m_item.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>Item in the request which caused the transaction to get cancelled.</p>
+     */
+    inline CancellationReason& AddItem(const char* key, const AttributeValue& value) { m_itemHasBeenSet = true; m_item.emplace(key, value); return *this; }
+
+
+    /**
+     * <p>Status code for the result of the cancelled transaction.</p>
+     */
+    inline const Aws::String& GetCode() const{ return m_code; }
+
+    /**
+     * <p>Status code for the result of the cancelled transaction.</p>
+     */
+    inline bool CodeHasBeenSet() const { return m_codeHasBeenSet; }
+
+    /**
+     * <p>Status code for the result of the cancelled transaction.</p>
+     */
+    inline void SetCode(const Aws::String& value) { m_codeHasBeenSet = true; m_code = value; }
+
+    /**
+     * <p>Status code for the result of the cancelled transaction.</p>
+     */
+    inline void SetCode(Aws::String&& value) { m_codeHasBeenSet = true; m_code = std::move(value); }
+
+    /**
+     * <p>Status code for the result of the cancelled transaction.</p>
+     */
+    inline void SetCode(const char* value) { m_codeHasBeenSet = true; m_code.assign(value); }
+
+    /**
+     * <p>Status code for the result of the cancelled transaction.</p>
+     */
+    inline CancellationReason& WithCode(const Aws::String& value) { SetCode(value); return *this;}
+
+    /**
+     * <p>Status code for the result of the cancelled transaction.</p>
+     */
+    inline CancellationReason& WithCode(Aws::String&& value) { SetCode(std::move(value)); return *this;}
+
+    /**
+     * <p>Status code for the result of the cancelled transaction.</p>
+     */
+    inline CancellationReason& WithCode(const char* value) { SetCode(value); return *this;}
+
+
+    /**
+     * <p>Cancellation reason message description.</p>
+     */
+    inline const Aws::String& GetMessage() const{ return m_message; }
+
+    /**
+     * <p>Cancellation reason message description.</p>
+     */
+    inline bool MessageHasBeenSet() const { return m_messageHasBeenSet; }
+
+    /**
+     * <p>Cancellation reason message description.</p>
+     */
+    inline void SetMessage(const Aws::String& value) { m_messageHasBeenSet = true; m_message = value; }
+
+    /**
+     * <p>Cancellation reason message description.</p>
+     */
+    inline void SetMessage(Aws::String&& value) { m_messageHasBeenSet = true; m_message = std::move(value); }
+
+    /**
+     * <p>Cancellation reason message description.</p>
+     */
+    inline void SetMessage(const char* value) { m_messageHasBeenSet = true; m_message.assign(value); }
+
+    /**
+     * <p>Cancellation reason message description.</p>
+     */
+    inline CancellationReason& WithMessage(const Aws::String& value) { SetMessage(value); return *this;}
+
+    /**
+     * <p>Cancellation reason message description.</p>
+     */
+    inline CancellationReason& WithMessage(Aws::String&& value) { SetMessage(std::move(value)); return *this;}
+
+    /**
+     * <p>Cancellation reason message description.</p>
+     */
+    inline CancellationReason& WithMessage(const char* value) { SetMessage(value); return *this;}
+
+  private:
+
+    Aws::Map<Aws::String, AttributeValue> m_item;
+    bool m_itemHasBeenSet;
+
+    Aws::String m_code;
+    bool m_codeHasBeenSet;
+
+    Aws::String m_message;
+    bool m_messageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/Capacity.h

@@ -0,0 +1,115 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents the amount of provisioned throughput capacity consumed on a table
+   * or an index.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/Capacity">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API Capacity
+  {
+  public:
+    Capacity();
+    Capacity(Aws::Utils::Json::JsonView jsonValue);
+    Capacity& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The total number of read capacity units consumed on a table or an index.</p>
+     */
+    inline double GetReadCapacityUnits() const{ return m_readCapacityUnits; }
+
+    /**
+     * <p>The total number of read capacity units consumed on a table or an index.</p>
+     */
+    inline bool ReadCapacityUnitsHasBeenSet() const { return m_readCapacityUnitsHasBeenSet; }
+
+    /**
+     * <p>The total number of read capacity units consumed on a table or an index.</p>
+     */
+    inline void SetReadCapacityUnits(double value) { m_readCapacityUnitsHasBeenSet = true; m_readCapacityUnits = value; }
+
+    /**
+     * <p>The total number of read capacity units consumed on a table or an index.</p>
+     */
+    inline Capacity& WithReadCapacityUnits(double value) { SetReadCapacityUnits(value); return *this;}
+
+
+    /**
+     * <p>The total number of write capacity units consumed on a table or an index.</p>
+     */
+    inline double GetWriteCapacityUnits() const{ return m_writeCapacityUnits; }
+
+    /**
+     * <p>The total number of write capacity units consumed on a table or an index.</p>
+     */
+    inline bool WriteCapacityUnitsHasBeenSet() const { return m_writeCapacityUnitsHasBeenSet; }
+
+    /**
+     * <p>The total number of write capacity units consumed on a table or an index.</p>
+     */
+    inline void SetWriteCapacityUnits(double value) { m_writeCapacityUnitsHasBeenSet = true; m_writeCapacityUnits = value; }
+
+    /**
+     * <p>The total number of write capacity units consumed on a table or an index.</p>
+     */
+    inline Capacity& WithWriteCapacityUnits(double value) { SetWriteCapacityUnits(value); return *this;}
+
+
+    /**
+     * <p>The total number of capacity units consumed on a table or an index.</p>
+     */
+    inline double GetCapacityUnits() const{ return m_capacityUnits; }
+
+    /**
+     * <p>The total number of capacity units consumed on a table or an index.</p>
+     */
+    inline bool CapacityUnitsHasBeenSet() const { return m_capacityUnitsHasBeenSet; }
+
+    /**
+     * <p>The total number of capacity units consumed on a table or an index.</p>
+     */
+    inline void SetCapacityUnits(double value) { m_capacityUnitsHasBeenSet = true; m_capacityUnits = value; }
+
+    /**
+     * <p>The total number of capacity units consumed on a table or an index.</p>
+     */
+    inline Capacity& WithCapacityUnits(double value) { SetCapacityUnits(value); return *this;}
+
+  private:
+
+    double m_readCapacityUnits;
+    bool m_readCapacityUnitsHasBeenSet;
+
+    double m_writeCapacityUnits;
+    bool m_writeCapacityUnitsHasBeenSet;
+
+    double m_capacityUnits;
+    bool m_capacityUnitsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/ComparisonOperator.h

@@ -0,0 +1,42 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+  enum class ComparisonOperator
+  {
+    NOT_SET,
+    EQ,
+    NE,
+    IN,
+    LE,
+    LT,
+    GE,
+    GT,
+    BETWEEN,
+    NOT_NULL,
+    NULL_,
+    CONTAINS,
+    NOT_CONTAINS,
+    BEGINS_WITH
+  };
+
+namespace ComparisonOperatorMapper
+{
+AWS_DYNAMODB_API ComparisonOperator GetComparisonOperatorForName(const Aws::String& name);
+
+AWS_DYNAMODB_API Aws::String GetNameForComparisonOperator(ComparisonOperator value);
+} // namespace ComparisonOperatorMapper
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/Condition.h

@@ -0,0 +1,834 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/dynamodb/model/ComparisonOperator.h>
+#include <aws/dynamodb/model/AttributeValue.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents the selection criteria for a <code>Query</code> or
+   * <code>Scan</code> operation:</p> <ul> <li> <p>For a <code>Query</code>
+   * operation, <code>Condition</code> is used for specifying the
+   * <code>KeyConditions</code> to use when querying a table or an index. For
+   * <code>KeyConditions</code>, only the following comparison operators are
+   * supported:</p> <p> <code>EQ | LE | LT | GE | GT | BEGINS_WITH | BETWEEN</code>
+   * </p> <p> <code>Condition</code> is also used in a <code>QueryFilter</code>,
+   * which evaluates the query results and returns only the desired values.</p> </li>
+   * <li> <p>For a <code>Scan</code> operation, <code>Condition</code> is used in a
+   * <code>ScanFilter</code>, which evaluates the scan results and returns only the
+   * desired values.</p> </li> </ul><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/Condition">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API Condition
+  {
+  public:
+    Condition();
+    Condition(Aws::Utils::Json::JsonView jsonValue);
+    Condition& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>One or more values to evaluate against the supplied attribute. The number of
+     * values in the list depends on the <code>ComparisonOperator</code> being
+     * used.</p> <p>For type Number, value comparisons are numeric.</p> <p>String value
+     * comparisons for greater than, equals, or less than are based on ASCII character
+     * code values. For example, <code>a</code> is greater than <code>A</code>, and
+     * <code>a</code> is greater than <code>B</code>. For a list of code values, see <a
+     * href="http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters">http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters</a>.</p>
+     * <p>For Binary, DynamoDB treats each byte of the binary data as unsigned when it
+     * compares binary values.</p>
+     */
+    inline const Aws::Vector<AttributeValue>& GetAttributeValueList() const{ return m_attributeValueList; }
+
+    /**
+     * <p>One or more values to evaluate against the supplied attribute. The number of
+     * values in the list depends on the <code>ComparisonOperator</code> being
+     * used.</p> <p>For type Number, value comparisons are numeric.</p> <p>String value
+     * comparisons for greater than, equals, or less than are based on ASCII character
+     * code values. For example, <code>a</code> is greater than <code>A</code>, and
+     * <code>a</code> is greater than <code>B</code>. For a list of code values, see <a
+     * href="http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters">http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters</a>.</p>
+     * <p>For Binary, DynamoDB treats each byte of the binary data as unsigned when it
+     * compares binary values.</p>
+     */
+    inline bool AttributeValueListHasBeenSet() const { return m_attributeValueListHasBeenSet; }
+
+    /**
+     * <p>One or more values to evaluate against the supplied attribute. The number of
+     * values in the list depends on the <code>ComparisonOperator</code> being
+     * used.</p> <p>For type Number, value comparisons are numeric.</p> <p>String value
+     * comparisons for greater than, equals, or less than are based on ASCII character
+     * code values. For example, <code>a</code> is greater than <code>A</code>, and
+     * <code>a</code> is greater than <code>B</code>. For a list of code values, see <a
+     * href="http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters">http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters</a>.</p>
+     * <p>For Binary, DynamoDB treats each byte of the binary data as unsigned when it
+     * compares binary values.</p>
+     */
+    inline void SetAttributeValueList(const Aws::Vector<AttributeValue>& value) { m_attributeValueListHasBeenSet = true; m_attributeValueList = value; }
+
+    /**
+     * <p>One or more values to evaluate against the supplied attribute. The number of
+     * values in the list depends on the <code>ComparisonOperator</code> being
+     * used.</p> <p>For type Number, value comparisons are numeric.</p> <p>String value
+     * comparisons for greater than, equals, or less than are based on ASCII character
+     * code values. For example, <code>a</code> is greater than <code>A</code>, and
+     * <code>a</code> is greater than <code>B</code>. For a list of code values, see <a
+     * href="http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters">http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters</a>.</p>
+     * <p>For Binary, DynamoDB treats each byte of the binary data as unsigned when it
+     * compares binary values.</p>
+     */
+    inline void SetAttributeValueList(Aws::Vector<AttributeValue>&& value) { m_attributeValueListHasBeenSet = true; m_attributeValueList = std::move(value); }
+
+    /**
+     * <p>One or more values to evaluate against the supplied attribute. The number of
+     * values in the list depends on the <code>ComparisonOperator</code> being
+     * used.</p> <p>For type Number, value comparisons are numeric.</p> <p>String value
+     * comparisons for greater than, equals, or less than are based on ASCII character
+     * code values. For example, <code>a</code> is greater than <code>A</code>, and
+     * <code>a</code> is greater than <code>B</code>. For a list of code values, see <a
+     * href="http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters">http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters</a>.</p>
+     * <p>For Binary, DynamoDB treats each byte of the binary data as unsigned when it
+     * compares binary values.</p>
+     */
+    inline Condition& WithAttributeValueList(const Aws::Vector<AttributeValue>& value) { SetAttributeValueList(value); return *this;}
+
+    /**
+     * <p>One or more values to evaluate against the supplied attribute. The number of
+     * values in the list depends on the <code>ComparisonOperator</code> being
+     * used.</p> <p>For type Number, value comparisons are numeric.</p> <p>String value
+     * comparisons for greater than, equals, or less than are based on ASCII character
+     * code values. For example, <code>a</code> is greater than <code>A</code>, and
+     * <code>a</code> is greater than <code>B</code>. For a list of code values, see <a
+     * href="http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters">http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters</a>.</p>
+     * <p>For Binary, DynamoDB treats each byte of the binary data as unsigned when it
+     * compares binary values.</p>
+     */
+    inline Condition& WithAttributeValueList(Aws::Vector<AttributeValue>&& value) { SetAttributeValueList(std::move(value)); return *this;}
+
+    /**
+     * <p>One or more values to evaluate against the supplied attribute. The number of
+     * values in the list depends on the <code>ComparisonOperator</code> being
+     * used.</p> <p>For type Number, value comparisons are numeric.</p> <p>String value
+     * comparisons for greater than, equals, or less than are based on ASCII character
+     * code values. For example, <code>a</code> is greater than <code>A</code>, and
+     * <code>a</code> is greater than <code>B</code>. For a list of code values, see <a
+     * href="http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters">http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters</a>.</p>
+     * <p>For Binary, DynamoDB treats each byte of the binary data as unsigned when it
+     * compares binary values.</p>
+     */
+    inline Condition& AddAttributeValueList(const AttributeValue& value) { m_attributeValueListHasBeenSet = true; m_attributeValueList.push_back(value); return *this; }
+
+    /**
+     * <p>One or more values to evaluate against the supplied attribute. The number of
+     * values in the list depends on the <code>ComparisonOperator</code> being
+     * used.</p> <p>For type Number, value comparisons are numeric.</p> <p>String value
+     * comparisons for greater than, equals, or less than are based on ASCII character
+     * code values. For example, <code>a</code> is greater than <code>A</code>, and
+     * <code>a</code> is greater than <code>B</code>. For a list of code values, see <a
+     * href="http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters">http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters</a>.</p>
+     * <p>For Binary, DynamoDB treats each byte of the binary data as unsigned when it
+     * compares binary values.</p>
+     */
+    inline Condition& AddAttributeValueList(AttributeValue&& value) { m_attributeValueListHasBeenSet = true; m_attributeValueList.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>A comparator for evaluating attributes. For example, equals, greater than,
+     * less than, etc.</p> <p>The following comparison operators are available:</p> <p>
+     * <code>EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS |
+     * BEGINS_WITH | IN | BETWEEN</code> </p> <p>The following are descriptions of each
+     * comparison operator.</p> <ul> <li> <p> <code>EQ</code> : Equal. <code>EQ</code>
+     * is supported for all data types, including lists and maps.</p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * element of type String, Number, Binary, String Set, Number Set, or Binary Set.
+     * If an item contains an <code>AttributeValue</code> element of a different type
+     * than the one provided in the request, the value does not match. For example,
+     * <code>{"S":"6"}</code> does not equal <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not equal <code>{"NS":["6", "2", "1"]}</code>.</p>
+     * <p/> </li> <li> <p> <code>NE</code> : Not equal. <code>NE</code> is supported
+     * for all data types, including lists and maps.</p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * of type String, Number, Binary, String Set, Number Set, or Binary Set. If an
+     * item contains an <code>AttributeValue</code> of a different type than the one
+     * provided in the request, the value does not match. For example,
+     * <code>{"S":"6"}</code> does not equal <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not equal <code>{"NS":["6", "2", "1"]}</code>.</p>
+     * <p/> </li> <li> <p> <code>LE</code> : Less than or equal. </p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * element of type String, Number, or Binary (not a set type). If an item contains
+     * an <code>AttributeValue</code> element of a different type than the one provided
+     * in the request, the value does not match. For example, <code>{"S":"6"}</code>
+     * does not equal <code>{"N":"6"}</code>. Also, <code>{"N":"6"}</code> does not
+     * compare to <code>{"NS":["6", "2", "1"]}</code>.</p> <p/> </li> <li> <p>
+     * <code>LT</code> : Less than. </p> <p> <code>AttributeValueList</code> can
+     * contain only one <code>AttributeValue</code> of type String, Number, or Binary
+     * (not a set type). If an item contains an <code>AttributeValue</code> element of
+     * a different type than the one provided in the request, the value does not match.
+     * For example, <code>{"S":"6"}</code> does not equal <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not compare to <code>{"NS":["6", "2",
+     * "1"]}</code>.</p> <p/> </li> <li> <p> <code>GE</code> : Greater than or equal.
+     * </p> <p> <code>AttributeValueList</code> can contain only one
+     * <code>AttributeValue</code> element of type String, Number, or Binary (not a set
+     * type). If an item contains an <code>AttributeValue</code> element of a different
+     * type than the one provided in the request, the value does not match. For
+     * example, <code>{"S":"6"}</code> does not equal <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not compare to <code>{"NS":["6", "2",
+     * "1"]}</code>.</p> <p/> </li> <li> <p> <code>GT</code> : Greater than. </p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * element of type String, Number, or Binary (not a set type). If an item contains
+     * an <code>AttributeValue</code> element of a different type than the one provided
+     * in the request, the value does not match. For example, <code>{"S":"6"}</code>
+     * does not equal <code>{"N":"6"}</code>. Also, <code>{"N":"6"}</code> does not
+     * compare to <code>{"NS":["6", "2", "1"]}</code>.</p> <p/> </li> <li> <p>
+     * <code>NOT_NULL</code> : The attribute exists. <code>NOT_NULL</code> is supported
+     * for all data types, including lists and maps.</p>  <p>This operator tests
+     * for the existence of an attribute, not its data type. If the data type of
+     * attribute "<code>a</code>" is null, and you evaluate it using
+     * <code>NOT_NULL</code>, the result is a Boolean <code>true</code>. This result is
+     * because the attribute "<code>a</code>" exists; its data type is not relevant to
+     * the <code>NOT_NULL</code> comparison operator.</p>  </li> <li> <p>
+     * <code>NULL</code> : The attribute does not exist. <code>NULL</code> is supported
+     * for all data types, including lists and maps.</p>  <p>This operator tests
+     * for the nonexistence of an attribute, not its data type. If the data type of
+     * attribute "<code>a</code>" is null, and you evaluate it using <code>NULL</code>,
+     * the result is a Boolean <code>false</code>. This is because the attribute
+     * "<code>a</code>" exists; its data type is not relevant to the <code>NULL</code>
+     * comparison operator.</p>  </li> <li> <p> <code>CONTAINS</code> : Checks
+     * for a subsequence, or value in a set.</p> <p> <code>AttributeValueList</code>
+     * can contain only one <code>AttributeValue</code> element of type String, Number,
+     * or Binary (not a set type). If the target attribute of the comparison is of type
+     * String, then the operator checks for a substring match. If the target attribute
+     * of the comparison is of type Binary, then the operator looks for a subsequence
+     * of the target that matches the input. If the target attribute of the comparison
+     * is a set ("<code>SS</code>", "<code>NS</code>", or "<code>BS</code>"), then the
+     * operator evaluates to true if it finds an exact match with any member of the
+     * set.</p> <p>CONTAINS is supported for lists: When evaluating "<code>a CONTAINS
+     * b</code>", "<code>a</code>" can be a list; however, "<code>b</code>" cannot be a
+     * set, a map, or a list.</p> </li> <li> <p> <code>NOT_CONTAINS</code> : Checks for
+     * absence of a subsequence, or absence of a value in a set.</p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * element of type String, Number, or Binary (not a set type). If the target
+     * attribute of the comparison is a String, then the operator checks for the
+     * absence of a substring match. If the target attribute of the comparison is
+     * Binary, then the operator checks for the absence of a subsequence of the target
+     * that matches the input. If the target attribute of the comparison is a set
+     * ("<code>SS</code>", "<code>NS</code>", or "<code>BS</code>"), then the operator
+     * evaluates to true if it <i>does not</i> find an exact match with any member of
+     * the set.</p> <p>NOT_CONTAINS is supported for lists: When evaluating "<code>a
+     * NOT CONTAINS b</code>", "<code>a</code>" can be a list; however,
+     * "<code>b</code>" cannot be a set, a map, or a list.</p> </li> <li> <p>
+     * <code>BEGINS_WITH</code> : Checks for a prefix. </p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * of type String or Binary (not a Number or a set type). The target attribute of
+     * the comparison must be of type String or Binary (not a Number or a set
+     * type).</p> <p/> </li> <li> <p> <code>IN</code> : Checks for matching elements in
+     * a list.</p> <p> <code>AttributeValueList</code> can contain one or more
+     * <code>AttributeValue</code> elements of type String, Number, or Binary. These
+     * attributes are compared against an existing attribute of an item. If any
+     * elements of the input are equal to the item attribute, the expression evaluates
+     * to true.</p> </li> <li> <p> <code>BETWEEN</code> : Greater than or equal to the
+     * first value, and less than or equal to the second value. </p> <p>
+     * <code>AttributeValueList</code> must contain two <code>AttributeValue</code>
+     * elements of the same type, either String, Number, or Binary (not a set type). A
+     * target attribute matches if the target value is greater than, or equal to, the
+     * first element and less than, or equal to, the second element. If an item
+     * contains an <code>AttributeValue</code> element of a different type than the one
+     * provided in the request, the value does not match. For example,
+     * <code>{"S":"6"}</code> does not compare to <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not compare to <code>{"NS":["6", "2", "1"]}</code>
+     * </p> </li> </ul> <p>For usage examples of <code>AttributeValueList</code> and
+     * <code>ComparisonOperator</code>, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.html">Legacy
+     * Conditional Parameters</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline const ComparisonOperator& GetComparisonOperator() const{ return m_comparisonOperator; }
+
+    /**
+     * <p>A comparator for evaluating attributes. For example, equals, greater than,
+     * less than, etc.</p> <p>The following comparison operators are available:</p> <p>
+     * <code>EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS |
+     * BEGINS_WITH | IN | BETWEEN</code> </p> <p>The following are descriptions of each
+     * comparison operator.</p> <ul> <li> <p> <code>EQ</code> : Equal. <code>EQ</code>
+     * is supported for all data types, including lists and maps.</p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * element of type String, Number, Binary, String Set, Number Set, or Binary Set.
+     * If an item contains an <code>AttributeValue</code> element of a different type
+     * than the one provided in the request, the value does not match. For example,
+     * <code>{"S":"6"}</code> does not equal <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not equal <code>{"NS":["6", "2", "1"]}</code>.</p>
+     * <p/> </li> <li> <p> <code>NE</code> : Not equal. <code>NE</code> is supported
+     * for all data types, including lists and maps.</p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * of type String, Number, Binary, String Set, Number Set, or Binary Set. If an
+     * item contains an <code>AttributeValue</code> of a different type than the one
+     * provided in the request, the value does not match. For example,
+     * <code>{"S":"6"}</code> does not equal <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not equal <code>{"NS":["6", "2", "1"]}</code>.</p>
+     * <p/> </li> <li> <p> <code>LE</code> : Less than or equal. </p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * element of type String, Number, or Binary (not a set type). If an item contains
+     * an <code>AttributeValue</code> element of a different type than the one provided
+     * in the request, the value does not match. For example, <code>{"S":"6"}</code>
+     * does not equal <code>{"N":"6"}</code>. Also, <code>{"N":"6"}</code> does not
+     * compare to <code>{"NS":["6", "2", "1"]}</code>.</p> <p/> </li> <li> <p>
+     * <code>LT</code> : Less than. </p> <p> <code>AttributeValueList</code> can
+     * contain only one <code>AttributeValue</code> of type String, Number, or Binary
+     * (not a set type). If an item contains an <code>AttributeValue</code> element of
+     * a different type than the one provided in the request, the value does not match.
+     * For example, <code>{"S":"6"}</code> does not equal <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not compare to <code>{"NS":["6", "2",
+     * "1"]}</code>.</p> <p/> </li> <li> <p> <code>GE</code> : Greater than or equal.
+     * </p> <p> <code>AttributeValueList</code> can contain only one
+     * <code>AttributeValue</code> element of type String, Number, or Binary (not a set
+     * type). If an item contains an <code>AttributeValue</code> element of a different
+     * type than the one provided in the request, the value does not match. For
+     * example, <code>{"S":"6"}</code> does not equal <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not compare to <code>{"NS":["6", "2",
+     * "1"]}</code>.</p> <p/> </li> <li> <p> <code>GT</code> : Greater than. </p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * element of type String, Number, or Binary (not a set type). If an item contains
+     * an <code>AttributeValue</code> element of a different type than the one provided
+     * in the request, the value does not match. For example, <code>{"S":"6"}</code>
+     * does not equal <code>{"N":"6"}</code>. Also, <code>{"N":"6"}</code> does not
+     * compare to <code>{"NS":["6", "2", "1"]}</code>.</p> <p/> </li> <li> <p>
+     * <code>NOT_NULL</code> : The attribute exists. <code>NOT_NULL</code> is supported
+     * for all data types, including lists and maps.</p>  <p>This operator tests
+     * for the existence of an attribute, not its data type. If the data type of
+     * attribute "<code>a</code>" is null, and you evaluate it using
+     * <code>NOT_NULL</code>, the result is a Boolean <code>true</code>. This result is
+     * because the attribute "<code>a</code>" exists; its data type is not relevant to
+     * the <code>NOT_NULL</code> comparison operator.</p>  </li> <li> <p>
+     * <code>NULL</code> : The attribute does not exist. <code>NULL</code> is supported
+     * for all data types, including lists and maps.</p>  <p>This operator tests
+     * for the nonexistence of an attribute, not its data type. If the data type of
+     * attribute "<code>a</code>" is null, and you evaluate it using <code>NULL</code>,
+     * the result is a Boolean <code>false</code>. This is because the attribute
+     * "<code>a</code>" exists; its data type is not relevant to the <code>NULL</code>
+     * comparison operator.</p>  </li> <li> <p> <code>CONTAINS</code> : Checks
+     * for a subsequence, or value in a set.</p> <p> <code>AttributeValueList</code>
+     * can contain only one <code>AttributeValue</code> element of type String, Number,
+     * or Binary (not a set type). If the target attribute of the comparison is of type
+     * String, then the operator checks for a substring match. If the target attribute
+     * of the comparison is of type Binary, then the operator looks for a subsequence
+     * of the target that matches the input. If the target attribute of the comparison
+     * is a set ("<code>SS</code>", "<code>NS</code>", or "<code>BS</code>"), then the
+     * operator evaluates to true if it finds an exact match with any member of the
+     * set.</p> <p>CONTAINS is supported for lists: When evaluating "<code>a CONTAINS
+     * b</code>", "<code>a</code>" can be a list; however, "<code>b</code>" cannot be a
+     * set, a map, or a list.</p> </li> <li> <p> <code>NOT_CONTAINS</code> : Checks for
+     * absence of a subsequence, or absence of a value in a set.</p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * element of type String, Number, or Binary (not a set type). If the target
+     * attribute of the comparison is a String, then the operator checks for the
+     * absence of a substring match. If the target attribute of the comparison is
+     * Binary, then the operator checks for the absence of a subsequence of the target
+     * that matches the input. If the target attribute of the comparison is a set
+     * ("<code>SS</code>", "<code>NS</code>", or "<code>BS</code>"), then the operator
+     * evaluates to true if it <i>does not</i> find an exact match with any member of
+     * the set.</p> <p>NOT_CONTAINS is supported for lists: When evaluating "<code>a
+     * NOT CONTAINS b</code>", "<code>a</code>" can be a list; however,
+     * "<code>b</code>" cannot be a set, a map, or a list.</p> </li> <li> <p>
+     * <code>BEGINS_WITH</code> : Checks for a prefix. </p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * of type String or Binary (not a Number or a set type). The target attribute of
+     * the comparison must be of type String or Binary (not a Number or a set
+     * type).</p> <p/> </li> <li> <p> <code>IN</code> : Checks for matching elements in
+     * a list.</p> <p> <code>AttributeValueList</code> can contain one or more
+     * <code>AttributeValue</code> elements of type String, Number, or Binary. These
+     * attributes are compared against an existing attribute of an item. If any
+     * elements of the input are equal to the item attribute, the expression evaluates
+     * to true.</p> </li> <li> <p> <code>BETWEEN</code> : Greater than or equal to the
+     * first value, and less than or equal to the second value. </p> <p>
+     * <code>AttributeValueList</code> must contain two <code>AttributeValue</code>
+     * elements of the same type, either String, Number, or Binary (not a set type). A
+     * target attribute matches if the target value is greater than, or equal to, the
+     * first element and less than, or equal to, the second element. If an item
+     * contains an <code>AttributeValue</code> element of a different type than the one
+     * provided in the request, the value does not match. For example,
+     * <code>{"S":"6"}</code> does not compare to <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not compare to <code>{"NS":["6", "2", "1"]}</code>
+     * </p> </li> </ul> <p>For usage examples of <code>AttributeValueList</code> and
+     * <code>ComparisonOperator</code>, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.html">Legacy
+     * Conditional Parameters</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline bool ComparisonOperatorHasBeenSet() const { return m_comparisonOperatorHasBeenSet; }
+
+    /**
+     * <p>A comparator for evaluating attributes. For example, equals, greater than,
+     * less than, etc.</p> <p>The following comparison operators are available:</p> <p>
+     * <code>EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS |
+     * BEGINS_WITH | IN | BETWEEN</code> </p> <p>The following are descriptions of each
+     * comparison operator.</p> <ul> <li> <p> <code>EQ</code> : Equal. <code>EQ</code>
+     * is supported for all data types, including lists and maps.</p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * element of type String, Number, Binary, String Set, Number Set, or Binary Set.
+     * If an item contains an <code>AttributeValue</code> element of a different type
+     * than the one provided in the request, the value does not match. For example,
+     * <code>{"S":"6"}</code> does not equal <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not equal <code>{"NS":["6", "2", "1"]}</code>.</p>
+     * <p/> </li> <li> <p> <code>NE</code> : Not equal. <code>NE</code> is supported
+     * for all data types, including lists and maps.</p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * of type String, Number, Binary, String Set, Number Set, or Binary Set. If an
+     * item contains an <code>AttributeValue</code> of a different type than the one
+     * provided in the request, the value does not match. For example,
+     * <code>{"S":"6"}</code> does not equal <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not equal <code>{"NS":["6", "2", "1"]}</code>.</p>
+     * <p/> </li> <li> <p> <code>LE</code> : Less than or equal. </p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * element of type String, Number, or Binary (not a set type). If an item contains
+     * an <code>AttributeValue</code> element of a different type than the one provided
+     * in the request, the value does not match. For example, <code>{"S":"6"}</code>
+     * does not equal <code>{"N":"6"}</code>. Also, <code>{"N":"6"}</code> does not
+     * compare to <code>{"NS":["6", "2", "1"]}</code>.</p> <p/> </li> <li> <p>
+     * <code>LT</code> : Less than. </p> <p> <code>AttributeValueList</code> can
+     * contain only one <code>AttributeValue</code> of type String, Number, or Binary
+     * (not a set type). If an item contains an <code>AttributeValue</code> element of
+     * a different type than the one provided in the request, the value does not match.
+     * For example, <code>{"S":"6"}</code> does not equal <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not compare to <code>{"NS":["6", "2",
+     * "1"]}</code>.</p> <p/> </li> <li> <p> <code>GE</code> : Greater than or equal.
+     * </p> <p> <code>AttributeValueList</code> can contain only one
+     * <code>AttributeValue</code> element of type String, Number, or Binary (not a set
+     * type). If an item contains an <code>AttributeValue</code> element of a different
+     * type than the one provided in the request, the value does not match. For
+     * example, <code>{"S":"6"}</code> does not equal <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not compare to <code>{"NS":["6", "2",
+     * "1"]}</code>.</p> <p/> </li> <li> <p> <code>GT</code> : Greater than. </p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * element of type String, Number, or Binary (not a set type). If an item contains
+     * an <code>AttributeValue</code> element of a different type than the one provided
+     * in the request, the value does not match. For example, <code>{"S":"6"}</code>
+     * does not equal <code>{"N":"6"}</code>. Also, <code>{"N":"6"}</code> does not
+     * compare to <code>{"NS":["6", "2", "1"]}</code>.</p> <p/> </li> <li> <p>
+     * <code>NOT_NULL</code> : The attribute exists. <code>NOT_NULL</code> is supported
+     * for all data types, including lists and maps.</p>  <p>This operator tests
+     * for the existence of an attribute, not its data type. If the data type of
+     * attribute "<code>a</code>" is null, and you evaluate it using
+     * <code>NOT_NULL</code>, the result is a Boolean <code>true</code>. This result is
+     * because the attribute "<code>a</code>" exists; its data type is not relevant to
+     * the <code>NOT_NULL</code> comparison operator.</p>  </li> <li> <p>
+     * <code>NULL</code> : The attribute does not exist. <code>NULL</code> is supported
+     * for all data types, including lists and maps.</p>  <p>This operator tests
+     * for the nonexistence of an attribute, not its data type. If the data type of
+     * attribute "<code>a</code>" is null, and you evaluate it using <code>NULL</code>,
+     * the result is a Boolean <code>false</code>. This is because the attribute
+     * "<code>a</code>" exists; its data type is not relevant to the <code>NULL</code>
+     * comparison operator.</p>  </li> <li> <p> <code>CONTAINS</code> : Checks
+     * for a subsequence, or value in a set.</p> <p> <code>AttributeValueList</code>
+     * can contain only one <code>AttributeValue</code> element of type String, Number,
+     * or Binary (not a set type). If the target attribute of the comparison is of type
+     * String, then the operator checks for a substring match. If the target attribute
+     * of the comparison is of type Binary, then the operator looks for a subsequence
+     * of the target that matches the input. If the target attribute of the comparison
+     * is a set ("<code>SS</code>", "<code>NS</code>", or "<code>BS</code>"), then the
+     * operator evaluates to true if it finds an exact match with any member of the
+     * set.</p> <p>CONTAINS is supported for lists: When evaluating "<code>a CONTAINS
+     * b</code>", "<code>a</code>" can be a list; however, "<code>b</code>" cannot be a
+     * set, a map, or a list.</p> </li> <li> <p> <code>NOT_CONTAINS</code> : Checks for
+     * absence of a subsequence, or absence of a value in a set.</p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * element of type String, Number, or Binary (not a set type). If the target
+     * attribute of the comparison is a String, then the operator checks for the
+     * absence of a substring match. If the target attribute of the comparison is
+     * Binary, then the operator checks for the absence of a subsequence of the target
+     * that matches the input. If the target attribute of the comparison is a set
+     * ("<code>SS</code>", "<code>NS</code>", or "<code>BS</code>"), then the operator
+     * evaluates to true if it <i>does not</i> find an exact match with any member of
+     * the set.</p> <p>NOT_CONTAINS is supported for lists: When evaluating "<code>a
+     * NOT CONTAINS b</code>", "<code>a</code>" can be a list; however,
+     * "<code>b</code>" cannot be a set, a map, or a list.</p> </li> <li> <p>
+     * <code>BEGINS_WITH</code> : Checks for a prefix. </p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * of type String or Binary (not a Number or a set type). The target attribute of
+     * the comparison must be of type String or Binary (not a Number or a set
+     * type).</p> <p/> </li> <li> <p> <code>IN</code> : Checks for matching elements in
+     * a list.</p> <p> <code>AttributeValueList</code> can contain one or more
+     * <code>AttributeValue</code> elements of type String, Number, or Binary. These
+     * attributes are compared against an existing attribute of an item. If any
+     * elements of the input are equal to the item attribute, the expression evaluates
+     * to true.</p> </li> <li> <p> <code>BETWEEN</code> : Greater than or equal to the
+     * first value, and less than or equal to the second value. </p> <p>
+     * <code>AttributeValueList</code> must contain two <code>AttributeValue</code>
+     * elements of the same type, either String, Number, or Binary (not a set type). A
+     * target attribute matches if the target value is greater than, or equal to, the
+     * first element and less than, or equal to, the second element. If an item
+     * contains an <code>AttributeValue</code> element of a different type than the one
+     * provided in the request, the value does not match. For example,
+     * <code>{"S":"6"}</code> does not compare to <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not compare to <code>{"NS":["6", "2", "1"]}</code>
+     * </p> </li> </ul> <p>For usage examples of <code>AttributeValueList</code> and
+     * <code>ComparisonOperator</code>, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.html">Legacy
+     * Conditional Parameters</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline void SetComparisonOperator(const ComparisonOperator& value) { m_comparisonOperatorHasBeenSet = true; m_comparisonOperator = value; }
+
+    /**
+     * <p>A comparator for evaluating attributes. For example, equals, greater than,
+     * less than, etc.</p> <p>The following comparison operators are available:</p> <p>
+     * <code>EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS |
+     * BEGINS_WITH | IN | BETWEEN</code> </p> <p>The following are descriptions of each
+     * comparison operator.</p> <ul> <li> <p> <code>EQ</code> : Equal. <code>EQ</code>
+     * is supported for all data types, including lists and maps.</p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * element of type String, Number, Binary, String Set, Number Set, or Binary Set.
+     * If an item contains an <code>AttributeValue</code> element of a different type
+     * than the one provided in the request, the value does not match. For example,
+     * <code>{"S":"6"}</code> does not equal <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not equal <code>{"NS":["6", "2", "1"]}</code>.</p>
+     * <p/> </li> <li> <p> <code>NE</code> : Not equal. <code>NE</code> is supported
+     * for all data types, including lists and maps.</p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * of type String, Number, Binary, String Set, Number Set, or Binary Set. If an
+     * item contains an <code>AttributeValue</code> of a different type than the one
+     * provided in the request, the value does not match. For example,
+     * <code>{"S":"6"}</code> does not equal <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not equal <code>{"NS":["6", "2", "1"]}</code>.</p>
+     * <p/> </li> <li> <p> <code>LE</code> : Less than or equal. </p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * element of type String, Number, or Binary (not a set type). If an item contains
+     * an <code>AttributeValue</code> element of a different type than the one provided
+     * in the request, the value does not match. For example, <code>{"S":"6"}</code>
+     * does not equal <code>{"N":"6"}</code>. Also, <code>{"N":"6"}</code> does not
+     * compare to <code>{"NS":["6", "2", "1"]}</code>.</p> <p/> </li> <li> <p>
+     * <code>LT</code> : Less than. </p> <p> <code>AttributeValueList</code> can
+     * contain only one <code>AttributeValue</code> of type String, Number, or Binary
+     * (not a set type). If an item contains an <code>AttributeValue</code> element of
+     * a different type than the one provided in the request, the value does not match.
+     * For example, <code>{"S":"6"}</code> does not equal <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not compare to <code>{"NS":["6", "2",
+     * "1"]}</code>.</p> <p/> </li> <li> <p> <code>GE</code> : Greater than or equal.
+     * </p> <p> <code>AttributeValueList</code> can contain only one
+     * <code>AttributeValue</code> element of type String, Number, or Binary (not a set
+     * type). If an item contains an <code>AttributeValue</code> element of a different
+     * type than the one provided in the request, the value does not match. For
+     * example, <code>{"S":"6"}</code> does not equal <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not compare to <code>{"NS":["6", "2",
+     * "1"]}</code>.</p> <p/> </li> <li> <p> <code>GT</code> : Greater than. </p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * element of type String, Number, or Binary (not a set type). If an item contains
+     * an <code>AttributeValue</code> element of a different type than the one provided
+     * in the request, the value does not match. For example, <code>{"S":"6"}</code>
+     * does not equal <code>{"N":"6"}</code>. Also, <code>{"N":"6"}</code> does not
+     * compare to <code>{"NS":["6", "2", "1"]}</code>.</p> <p/> </li> <li> <p>
+     * <code>NOT_NULL</code> : The attribute exists. <code>NOT_NULL</code> is supported
+     * for all data types, including lists and maps.</p>  <p>This operator tests
+     * for the existence of an attribute, not its data type. If the data type of
+     * attribute "<code>a</code>" is null, and you evaluate it using
+     * <code>NOT_NULL</code>, the result is a Boolean <code>true</code>. This result is
+     * because the attribute "<code>a</code>" exists; its data type is not relevant to
+     * the <code>NOT_NULL</code> comparison operator.</p>  </li> <li> <p>
+     * <code>NULL</code> : The attribute does not exist. <code>NULL</code> is supported
+     * for all data types, including lists and maps.</p>  <p>This operator tests
+     * for the nonexistence of an attribute, not its data type. If the data type of
+     * attribute "<code>a</code>" is null, and you evaluate it using <code>NULL</code>,
+     * the result is a Boolean <code>false</code>. This is because the attribute
+     * "<code>a</code>" exists; its data type is not relevant to the <code>NULL</code>
+     * comparison operator.</p>  </li> <li> <p> <code>CONTAINS</code> : Checks
+     * for a subsequence, or value in a set.</p> <p> <code>AttributeValueList</code>
+     * can contain only one <code>AttributeValue</code> element of type String, Number,
+     * or Binary (not a set type). If the target attribute of the comparison is of type
+     * String, then the operator checks for a substring match. If the target attribute
+     * of the comparison is of type Binary, then the operator looks for a subsequence
+     * of the target that matches the input. If the target attribute of the comparison
+     * is a set ("<code>SS</code>", "<code>NS</code>", or "<code>BS</code>"), then the
+     * operator evaluates to true if it finds an exact match with any member of the
+     * set.</p> <p>CONTAINS is supported for lists: When evaluating "<code>a CONTAINS
+     * b</code>", "<code>a</code>" can be a list; however, "<code>b</code>" cannot be a
+     * set, a map, or a list.</p> </li> <li> <p> <code>NOT_CONTAINS</code> : Checks for
+     * absence of a subsequence, or absence of a value in a set.</p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * element of type String, Number, or Binary (not a set type). If the target
+     * attribute of the comparison is a String, then the operator checks for the
+     * absence of a substring match. If the target attribute of the comparison is
+     * Binary, then the operator checks for the absence of a subsequence of the target
+     * that matches the input. If the target attribute of the comparison is a set
+     * ("<code>SS</code>", "<code>NS</code>", or "<code>BS</code>"), then the operator
+     * evaluates to true if it <i>does not</i> find an exact match with any member of
+     * the set.</p> <p>NOT_CONTAINS is supported for lists: When evaluating "<code>a
+     * NOT CONTAINS b</code>", "<code>a</code>" can be a list; however,
+     * "<code>b</code>" cannot be a set, a map, or a list.</p> </li> <li> <p>
+     * <code>BEGINS_WITH</code> : Checks for a prefix. </p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * of type String or Binary (not a Number or a set type). The target attribute of
+     * the comparison must be of type String or Binary (not a Number or a set
+     * type).</p> <p/> </li> <li> <p> <code>IN</code> : Checks for matching elements in
+     * a list.</p> <p> <code>AttributeValueList</code> can contain one or more
+     * <code>AttributeValue</code> elements of type String, Number, or Binary. These
+     * attributes are compared against an existing attribute of an item. If any
+     * elements of the input are equal to the item attribute, the expression evaluates
+     * to true.</p> </li> <li> <p> <code>BETWEEN</code> : Greater than or equal to the
+     * first value, and less than or equal to the second value. </p> <p>
+     * <code>AttributeValueList</code> must contain two <code>AttributeValue</code>
+     * elements of the same type, either String, Number, or Binary (not a set type). A
+     * target attribute matches if the target value is greater than, or equal to, the
+     * first element and less than, or equal to, the second element. If an item
+     * contains an <code>AttributeValue</code> element of a different type than the one
+     * provided in the request, the value does not match. For example,
+     * <code>{"S":"6"}</code> does not compare to <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not compare to <code>{"NS":["6", "2", "1"]}</code>
+     * </p> </li> </ul> <p>For usage examples of <code>AttributeValueList</code> and
+     * <code>ComparisonOperator</code>, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.html">Legacy
+     * Conditional Parameters</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline void SetComparisonOperator(ComparisonOperator&& value) { m_comparisonOperatorHasBeenSet = true; m_comparisonOperator = std::move(value); }
+
+    /**
+     * <p>A comparator for evaluating attributes. For example, equals, greater than,
+     * less than, etc.</p> <p>The following comparison operators are available:</p> <p>
+     * <code>EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS |
+     * BEGINS_WITH | IN | BETWEEN</code> </p> <p>The following are descriptions of each
+     * comparison operator.</p> <ul> <li> <p> <code>EQ</code> : Equal. <code>EQ</code>
+     * is supported for all data types, including lists and maps.</p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * element of type String, Number, Binary, String Set, Number Set, or Binary Set.
+     * If an item contains an <code>AttributeValue</code> element of a different type
+     * than the one provided in the request, the value does not match. For example,
+     * <code>{"S":"6"}</code> does not equal <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not equal <code>{"NS":["6", "2", "1"]}</code>.</p>
+     * <p/> </li> <li> <p> <code>NE</code> : Not equal. <code>NE</code> is supported
+     * for all data types, including lists and maps.</p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * of type String, Number, Binary, String Set, Number Set, or Binary Set. If an
+     * item contains an <code>AttributeValue</code> of a different type than the one
+     * provided in the request, the value does not match. For example,
+     * <code>{"S":"6"}</code> does not equal <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not equal <code>{"NS":["6", "2", "1"]}</code>.</p>
+     * <p/> </li> <li> <p> <code>LE</code> : Less than or equal. </p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * element of type String, Number, or Binary (not a set type). If an item contains
+     * an <code>AttributeValue</code> element of a different type than the one provided
+     * in the request, the value does not match. For example, <code>{"S":"6"}</code>
+     * does not equal <code>{"N":"6"}</code>. Also, <code>{"N":"6"}</code> does not
+     * compare to <code>{"NS":["6", "2", "1"]}</code>.</p> <p/> </li> <li> <p>
+     * <code>LT</code> : Less than. </p> <p> <code>AttributeValueList</code> can
+     * contain only one <code>AttributeValue</code> of type String, Number, or Binary
+     * (not a set type). If an item contains an <code>AttributeValue</code> element of
+     * a different type than the one provided in the request, the value does not match.
+     * For example, <code>{"S":"6"}</code> does not equal <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not compare to <code>{"NS":["6", "2",
+     * "1"]}</code>.</p> <p/> </li> <li> <p> <code>GE</code> : Greater than or equal.
+     * </p> <p> <code>AttributeValueList</code> can contain only one
+     * <code>AttributeValue</code> element of type String, Number, or Binary (not a set
+     * type). If an item contains an <code>AttributeValue</code> element of a different
+     * type than the one provided in the request, the value does not match. For
+     * example, <code>{"S":"6"}</code> does not equal <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not compare to <code>{"NS":["6", "2",
+     * "1"]}</code>.</p> <p/> </li> <li> <p> <code>GT</code> : Greater than. </p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * element of type String, Number, or Binary (not a set type). If an item contains
+     * an <code>AttributeValue</code> element of a different type than the one provided
+     * in the request, the value does not match. For example, <code>{"S":"6"}</code>
+     * does not equal <code>{"N":"6"}</code>. Also, <code>{"N":"6"}</code> does not
+     * compare to <code>{"NS":["6", "2", "1"]}</code>.</p> <p/> </li> <li> <p>
+     * <code>NOT_NULL</code> : The attribute exists. <code>NOT_NULL</code> is supported
+     * for all data types, including lists and maps.</p>  <p>This operator tests
+     * for the existence of an attribute, not its data type. If the data type of
+     * attribute "<code>a</code>" is null, and you evaluate it using
+     * <code>NOT_NULL</code>, the result is a Boolean <code>true</code>. This result is
+     * because the attribute "<code>a</code>" exists; its data type is not relevant to
+     * the <code>NOT_NULL</code> comparison operator.</p>  </li> <li> <p>
+     * <code>NULL</code> : The attribute does not exist. <code>NULL</code> is supported
+     * for all data types, including lists and maps.</p>  <p>This operator tests
+     * for the nonexistence of an attribute, not its data type. If the data type of
+     * attribute "<code>a</code>" is null, and you evaluate it using <code>NULL</code>,
+     * the result is a Boolean <code>false</code>. This is because the attribute
+     * "<code>a</code>" exists; its data type is not relevant to the <code>NULL</code>
+     * comparison operator.</p>  </li> <li> <p> <code>CONTAINS</code> : Checks
+     * for a subsequence, or value in a set.</p> <p> <code>AttributeValueList</code>
+     * can contain only one <code>AttributeValue</code> element of type String, Number,
+     * or Binary (not a set type). If the target attribute of the comparison is of type
+     * String, then the operator checks for a substring match. If the target attribute
+     * of the comparison is of type Binary, then the operator looks for a subsequence
+     * of the target that matches the input. If the target attribute of the comparison
+     * is a set ("<code>SS</code>", "<code>NS</code>", or "<code>BS</code>"), then the
+     * operator evaluates to true if it finds an exact match with any member of the
+     * set.</p> <p>CONTAINS is supported for lists: When evaluating "<code>a CONTAINS
+     * b</code>", "<code>a</code>" can be a list; however, "<code>b</code>" cannot be a
+     * set, a map, or a list.</p> </li> <li> <p> <code>NOT_CONTAINS</code> : Checks for
+     * absence of a subsequence, or absence of a value in a set.</p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * element of type String, Number, or Binary (not a set type). If the target
+     * attribute of the comparison is a String, then the operator checks for the
+     * absence of a substring match. If the target attribute of the comparison is
+     * Binary, then the operator checks for the absence of a subsequence of the target
+     * that matches the input. If the target attribute of the comparison is a set
+     * ("<code>SS</code>", "<code>NS</code>", or "<code>BS</code>"), then the operator
+     * evaluates to true if it <i>does not</i> find an exact match with any member of
+     * the set.</p> <p>NOT_CONTAINS is supported for lists: When evaluating "<code>a
+     * NOT CONTAINS b</code>", "<code>a</code>" can be a list; however,
+     * "<code>b</code>" cannot be a set, a map, or a list.</p> </li> <li> <p>
+     * <code>BEGINS_WITH</code> : Checks for a prefix. </p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * of type String or Binary (not a Number or a set type). The target attribute of
+     * the comparison must be of type String or Binary (not a Number or a set
+     * type).</p> <p/> </li> <li> <p> <code>IN</code> : Checks for matching elements in
+     * a list.</p> <p> <code>AttributeValueList</code> can contain one or more
+     * <code>AttributeValue</code> elements of type String, Number, or Binary. These
+     * attributes are compared against an existing attribute of an item. If any
+     * elements of the input are equal to the item attribute, the expression evaluates
+     * to true.</p> </li> <li> <p> <code>BETWEEN</code> : Greater than or equal to the
+     * first value, and less than or equal to the second value. </p> <p>
+     * <code>AttributeValueList</code> must contain two <code>AttributeValue</code>
+     * elements of the same type, either String, Number, or Binary (not a set type). A
+     * target attribute matches if the target value is greater than, or equal to, the
+     * first element and less than, or equal to, the second element. If an item
+     * contains an <code>AttributeValue</code> element of a different type than the one
+     * provided in the request, the value does not match. For example,
+     * <code>{"S":"6"}</code> does not compare to <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not compare to <code>{"NS":["6", "2", "1"]}</code>
+     * </p> </li> </ul> <p>For usage examples of <code>AttributeValueList</code> and
+     * <code>ComparisonOperator</code>, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.html">Legacy
+     * Conditional Parameters</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline Condition& WithComparisonOperator(const ComparisonOperator& value) { SetComparisonOperator(value); return *this;}
+
+    /**
+     * <p>A comparator for evaluating attributes. For example, equals, greater than,
+     * less than, etc.</p> <p>The following comparison operators are available:</p> <p>
+     * <code>EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS |
+     * BEGINS_WITH | IN | BETWEEN</code> </p> <p>The following are descriptions of each
+     * comparison operator.</p> <ul> <li> <p> <code>EQ</code> : Equal. <code>EQ</code>
+     * is supported for all data types, including lists and maps.</p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * element of type String, Number, Binary, String Set, Number Set, or Binary Set.
+     * If an item contains an <code>AttributeValue</code> element of a different type
+     * than the one provided in the request, the value does not match. For example,
+     * <code>{"S":"6"}</code> does not equal <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not equal <code>{"NS":["6", "2", "1"]}</code>.</p>
+     * <p/> </li> <li> <p> <code>NE</code> : Not equal. <code>NE</code> is supported
+     * for all data types, including lists and maps.</p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * of type String, Number, Binary, String Set, Number Set, or Binary Set. If an
+     * item contains an <code>AttributeValue</code> of a different type than the one
+     * provided in the request, the value does not match. For example,
+     * <code>{"S":"6"}</code> does not equal <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not equal <code>{"NS":["6", "2", "1"]}</code>.</p>
+     * <p/> </li> <li> <p> <code>LE</code> : Less than or equal. </p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * element of type String, Number, or Binary (not a set type). If an item contains
+     * an <code>AttributeValue</code> element of a different type than the one provided
+     * in the request, the value does not match. For example, <code>{"S":"6"}</code>
+     * does not equal <code>{"N":"6"}</code>. Also, <code>{"N":"6"}</code> does not
+     * compare to <code>{"NS":["6", "2", "1"]}</code>.</p> <p/> </li> <li> <p>
+     * <code>LT</code> : Less than. </p> <p> <code>AttributeValueList</code> can
+     * contain only one <code>AttributeValue</code> of type String, Number, or Binary
+     * (not a set type). If an item contains an <code>AttributeValue</code> element of
+     * a different type than the one provided in the request, the value does not match.
+     * For example, <code>{"S":"6"}</code> does not equal <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not compare to <code>{"NS":["6", "2",
+     * "1"]}</code>.</p> <p/> </li> <li> <p> <code>GE</code> : Greater than or equal.
+     * </p> <p> <code>AttributeValueList</code> can contain only one
+     * <code>AttributeValue</code> element of type String, Number, or Binary (not a set
+     * type). If an item contains an <code>AttributeValue</code> element of a different
+     * type than the one provided in the request, the value does not match. For
+     * example, <code>{"S":"6"}</code> does not equal <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not compare to <code>{"NS":["6", "2",
+     * "1"]}</code>.</p> <p/> </li> <li> <p> <code>GT</code> : Greater than. </p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * element of type String, Number, or Binary (not a set type). If an item contains
+     * an <code>AttributeValue</code> element of a different type than the one provided
+     * in the request, the value does not match. For example, <code>{"S":"6"}</code>
+     * does not equal <code>{"N":"6"}</code>. Also, <code>{"N":"6"}</code> does not
+     * compare to <code>{"NS":["6", "2", "1"]}</code>.</p> <p/> </li> <li> <p>
+     * <code>NOT_NULL</code> : The attribute exists. <code>NOT_NULL</code> is supported
+     * for all data types, including lists and maps.</p>  <p>This operator tests
+     * for the existence of an attribute, not its data type. If the data type of
+     * attribute "<code>a</code>" is null, and you evaluate it using
+     * <code>NOT_NULL</code>, the result is a Boolean <code>true</code>. This result is
+     * because the attribute "<code>a</code>" exists; its data type is not relevant to
+     * the <code>NOT_NULL</code> comparison operator.</p>  </li> <li> <p>
+     * <code>NULL</code> : The attribute does not exist. <code>NULL</code> is supported
+     * for all data types, including lists and maps.</p>  <p>This operator tests
+     * for the nonexistence of an attribute, not its data type. If the data type of
+     * attribute "<code>a</code>" is null, and you evaluate it using <code>NULL</code>,
+     * the result is a Boolean <code>false</code>. This is because the attribute
+     * "<code>a</code>" exists; its data type is not relevant to the <code>NULL</code>
+     * comparison operator.</p>  </li> <li> <p> <code>CONTAINS</code> : Checks
+     * for a subsequence, or value in a set.</p> <p> <code>AttributeValueList</code>
+     * can contain only one <code>AttributeValue</code> element of type String, Number,
+     * or Binary (not a set type). If the target attribute of the comparison is of type
+     * String, then the operator checks for a substring match. If the target attribute
+     * of the comparison is of type Binary, then the operator looks for a subsequence
+     * of the target that matches the input. If the target attribute of the comparison
+     * is a set ("<code>SS</code>", "<code>NS</code>", or "<code>BS</code>"), then the
+     * operator evaluates to true if it finds an exact match with any member of the
+     * set.</p> <p>CONTAINS is supported for lists: When evaluating "<code>a CONTAINS
+     * b</code>", "<code>a</code>" can be a list; however, "<code>b</code>" cannot be a
+     * set, a map, or a list.</p> </li> <li> <p> <code>NOT_CONTAINS</code> : Checks for
+     * absence of a subsequence, or absence of a value in a set.</p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * element of type String, Number, or Binary (not a set type). If the target
+     * attribute of the comparison is a String, then the operator checks for the
+     * absence of a substring match. If the target attribute of the comparison is
+     * Binary, then the operator checks for the absence of a subsequence of the target
+     * that matches the input. If the target attribute of the comparison is a set
+     * ("<code>SS</code>", "<code>NS</code>", or "<code>BS</code>"), then the operator
+     * evaluates to true if it <i>does not</i> find an exact match with any member of
+     * the set.</p> <p>NOT_CONTAINS is supported for lists: When evaluating "<code>a
+     * NOT CONTAINS b</code>", "<code>a</code>" can be a list; however,
+     * "<code>b</code>" cannot be a set, a map, or a list.</p> </li> <li> <p>
+     * <code>BEGINS_WITH</code> : Checks for a prefix. </p> <p>
+     * <code>AttributeValueList</code> can contain only one <code>AttributeValue</code>
+     * of type String or Binary (not a Number or a set type). The target attribute of
+     * the comparison must be of type String or Binary (not a Number or a set
+     * type).</p> <p/> </li> <li> <p> <code>IN</code> : Checks for matching elements in
+     * a list.</p> <p> <code>AttributeValueList</code> can contain one or more
+     * <code>AttributeValue</code> elements of type String, Number, or Binary. These
+     * attributes are compared against an existing attribute of an item. If any
+     * elements of the input are equal to the item attribute, the expression evaluates
+     * to true.</p> </li> <li> <p> <code>BETWEEN</code> : Greater than or equal to the
+     * first value, and less than or equal to the second value. </p> <p>
+     * <code>AttributeValueList</code> must contain two <code>AttributeValue</code>
+     * elements of the same type, either String, Number, or Binary (not a set type). A
+     * target attribute matches if the target value is greater than, or equal to, the
+     * first element and less than, or equal to, the second element. If an item
+     * contains an <code>AttributeValue</code> element of a different type than the one
+     * provided in the request, the value does not match. For example,
+     * <code>{"S":"6"}</code> does not compare to <code>{"N":"6"}</code>. Also,
+     * <code>{"N":"6"}</code> does not compare to <code>{"NS":["6", "2", "1"]}</code>
+     * </p> </li> </ul> <p>For usage examples of <code>AttributeValueList</code> and
+     * <code>ComparisonOperator</code>, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.html">Legacy
+     * Conditional Parameters</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline Condition& WithComparisonOperator(ComparisonOperator&& value) { SetComparisonOperator(std::move(value)); return *this;}
+
+  private:
+
+    Aws::Vector<AttributeValue> m_attributeValueList;
+    bool m_attributeValueListHasBeenSet;
+
+    ComparisonOperator m_comparisonOperator;
+    bool m_comparisonOperatorHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/ConditionCheck.h

@@ -0,0 +1,405 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/dynamodb/model/ReturnValuesOnConditionCheckFailure.h>
+#include <aws/dynamodb/model/AttributeValue.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents a request to perform a check that an item exists or to check the
+   * condition of specific attributes of the item.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ConditionCheck">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API ConditionCheck
+  {
+  public:
+    ConditionCheck();
+    ConditionCheck(Aws::Utils::Json::JsonView jsonValue);
+    ConditionCheck& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The primary key of the item to be checked. Each element consists of an
+     * attribute name and a value for that attribute.</p>
+     */
+    inline const Aws::Map<Aws::String, AttributeValue>& GetKey() const{ return m_key; }
+
+    /**
+     * <p>The primary key of the item to be checked. Each element consists of an
+     * attribute name and a value for that attribute.</p>
+     */
+    inline bool KeyHasBeenSet() const { return m_keyHasBeenSet; }
+
+    /**
+     * <p>The primary key of the item to be checked. Each element consists of an
+     * attribute name and a value for that attribute.</p>
+     */
+    inline void SetKey(const Aws::Map<Aws::String, AttributeValue>& value) { m_keyHasBeenSet = true; m_key = value; }
+
+    /**
+     * <p>The primary key of the item to be checked. Each element consists of an
+     * attribute name and a value for that attribute.</p>
+     */
+    inline void SetKey(Aws::Map<Aws::String, AttributeValue>&& value) { m_keyHasBeenSet = true; m_key = std::move(value); }
+
+    /**
+     * <p>The primary key of the item to be checked. Each element consists of an
+     * attribute name and a value for that attribute.</p>
+     */
+    inline ConditionCheck& WithKey(const Aws::Map<Aws::String, AttributeValue>& value) { SetKey(value); return *this;}
+
+    /**
+     * <p>The primary key of the item to be checked. Each element consists of an
+     * attribute name and a value for that attribute.</p>
+     */
+    inline ConditionCheck& WithKey(Aws::Map<Aws::String, AttributeValue>&& value) { SetKey(std::move(value)); return *this;}
+
+    /**
+     * <p>The primary key of the item to be checked. Each element consists of an
+     * attribute name and a value for that attribute.</p>
+     */
+    inline ConditionCheck& AddKey(const Aws::String& key, const AttributeValue& value) { m_keyHasBeenSet = true; m_key.emplace(key, value); return *this; }
+
+    /**
+     * <p>The primary key of the item to be checked. Each element consists of an
+     * attribute name and a value for that attribute.</p>
+     */
+    inline ConditionCheck& AddKey(Aws::String&& key, const AttributeValue& value) { m_keyHasBeenSet = true; m_key.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>The primary key of the item to be checked. Each element consists of an
+     * attribute name and a value for that attribute.</p>
+     */
+    inline ConditionCheck& AddKey(const Aws::String& key, AttributeValue&& value) { m_keyHasBeenSet = true; m_key.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>The primary key of the item to be checked. Each element consists of an
+     * attribute name and a value for that attribute.</p>
+     */
+    inline ConditionCheck& AddKey(Aws::String&& key, AttributeValue&& value) { m_keyHasBeenSet = true; m_key.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>The primary key of the item to be checked. Each element consists of an
+     * attribute name and a value for that attribute.</p>
+     */
+    inline ConditionCheck& AddKey(const char* key, AttributeValue&& value) { m_keyHasBeenSet = true; m_key.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>The primary key of the item to be checked. Each element consists of an
+     * attribute name and a value for that attribute.</p>
+     */
+    inline ConditionCheck& AddKey(const char* key, const AttributeValue& value) { m_keyHasBeenSet = true; m_key.emplace(key, value); return *this; }
+
+
+    /**
+     * <p>Name of the table for the check item request.</p>
+     */
+    inline const Aws::String& GetTableName() const{ return m_tableName; }
+
+    /**
+     * <p>Name of the table for the check item request.</p>
+     */
+    inline bool TableNameHasBeenSet() const { return m_tableNameHasBeenSet; }
+
+    /**
+     * <p>Name of the table for the check item request.</p>
+     */
+    inline void SetTableName(const Aws::String& value) { m_tableNameHasBeenSet = true; m_tableName = value; }
+
+    /**
+     * <p>Name of the table for the check item request.</p>
+     */
+    inline void SetTableName(Aws::String&& value) { m_tableNameHasBeenSet = true; m_tableName = std::move(value); }
+
+    /**
+     * <p>Name of the table for the check item request.</p>
+     */
+    inline void SetTableName(const char* value) { m_tableNameHasBeenSet = true; m_tableName.assign(value); }
+
+    /**
+     * <p>Name of the table for the check item request.</p>
+     */
+    inline ConditionCheck& WithTableName(const Aws::String& value) { SetTableName(value); return *this;}
+
+    /**
+     * <p>Name of the table for the check item request.</p>
+     */
+    inline ConditionCheck& WithTableName(Aws::String&& value) { SetTableName(std::move(value)); return *this;}
+
+    /**
+     * <p>Name of the table for the check item request.</p>
+     */
+    inline ConditionCheck& WithTableName(const char* value) { SetTableName(value); return *this;}
+
+
+    /**
+     * <p>A condition that must be satisfied in order for a conditional update to
+     * succeed.</p>
+     */
+    inline const Aws::String& GetConditionExpression() const{ return m_conditionExpression; }
+
+    /**
+     * <p>A condition that must be satisfied in order for a conditional update to
+     * succeed.</p>
+     */
+    inline bool ConditionExpressionHasBeenSet() const { return m_conditionExpressionHasBeenSet; }
+
+    /**
+     * <p>A condition that must be satisfied in order for a conditional update to
+     * succeed.</p>
+     */
+    inline void SetConditionExpression(const Aws::String& value) { m_conditionExpressionHasBeenSet = true; m_conditionExpression = value; }
+
+    /**
+     * <p>A condition that must be satisfied in order for a conditional update to
+     * succeed.</p>
+     */
+    inline void SetConditionExpression(Aws::String&& value) { m_conditionExpressionHasBeenSet = true; m_conditionExpression = std::move(value); }
+
+    /**
+     * <p>A condition that must be satisfied in order for a conditional update to
+     * succeed.</p>
+     */
+    inline void SetConditionExpression(const char* value) { m_conditionExpressionHasBeenSet = true; m_conditionExpression.assign(value); }
+
+    /**
+     * <p>A condition that must be satisfied in order for a conditional update to
+     * succeed.</p>
+     */
+    inline ConditionCheck& WithConditionExpression(const Aws::String& value) { SetConditionExpression(value); return *this;}
+
+    /**
+     * <p>A condition that must be satisfied in order for a conditional update to
+     * succeed.</p>
+     */
+    inline ConditionCheck& WithConditionExpression(Aws::String&& value) { SetConditionExpression(std::move(value)); return *this;}
+
+    /**
+     * <p>A condition that must be satisfied in order for a conditional update to
+     * succeed.</p>
+     */
+    inline ConditionCheck& WithConditionExpression(const char* value) { SetConditionExpression(value); return *this;}
+
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression.</p>
+     */
+    inline const Aws::Map<Aws::String, Aws::String>& GetExpressionAttributeNames() const{ return m_expressionAttributeNames; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression.</p>
+     */
+    inline bool ExpressionAttributeNamesHasBeenSet() const { return m_expressionAttributeNamesHasBeenSet; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression.</p>
+     */
+    inline void SetExpressionAttributeNames(const Aws::Map<Aws::String, Aws::String>& value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames = value; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression.</p>
+     */
+    inline void SetExpressionAttributeNames(Aws::Map<Aws::String, Aws::String>&& value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames = std::move(value); }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression.</p>
+     */
+    inline ConditionCheck& WithExpressionAttributeNames(const Aws::Map<Aws::String, Aws::String>& value) { SetExpressionAttributeNames(value); return *this;}
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression.</p>
+     */
+    inline ConditionCheck& WithExpressionAttributeNames(Aws::Map<Aws::String, Aws::String>&& value) { SetExpressionAttributeNames(std::move(value)); return *this;}
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression.</p>
+     */
+    inline ConditionCheck& AddExpressionAttributeNames(const Aws::String& key, const Aws::String& value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames.emplace(key, value); return *this; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression.</p>
+     */
+    inline ConditionCheck& AddExpressionAttributeNames(Aws::String&& key, const Aws::String& value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression.</p>
+     */
+    inline ConditionCheck& AddExpressionAttributeNames(const Aws::String& key, Aws::String&& value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression.</p>
+     */
+    inline ConditionCheck& AddExpressionAttributeNames(Aws::String&& key, Aws::String&& value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression.</p>
+     */
+    inline ConditionCheck& AddExpressionAttributeNames(const char* key, Aws::String&& value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression.</p>
+     */
+    inline ConditionCheck& AddExpressionAttributeNames(Aws::String&& key, const char* value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression.</p>
+     */
+    inline ConditionCheck& AddExpressionAttributeNames(const char* key, const char* value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames.emplace(key, value); return *this; }
+
+
+    /**
+     * <p>One or more values that can be substituted in an expression.</p>
+     */
+    inline const Aws::Map<Aws::String, AttributeValue>& GetExpressionAttributeValues() const{ return m_expressionAttributeValues; }
+
+    /**
+     * <p>One or more values that can be substituted in an expression.</p>
+     */
+    inline bool ExpressionAttributeValuesHasBeenSet() const { return m_expressionAttributeValuesHasBeenSet; }
+
+    /**
+     * <p>One or more values that can be substituted in an expression.</p>
+     */
+    inline void SetExpressionAttributeValues(const Aws::Map<Aws::String, AttributeValue>& value) { m_expressionAttributeValuesHasBeenSet = true; m_expressionAttributeValues = value; }
+
+    /**
+     * <p>One or more values that can be substituted in an expression.</p>
+     */
+    inline void SetExpressionAttributeValues(Aws::Map<Aws::String, AttributeValue>&& value) { m_expressionAttributeValuesHasBeenSet = true; m_expressionAttributeValues = std::move(value); }
+
+    /**
+     * <p>One or more values that can be substituted in an expression.</p>
+     */
+    inline ConditionCheck& WithExpressionAttributeValues(const Aws::Map<Aws::String, AttributeValue>& value) { SetExpressionAttributeValues(value); return *this;}
+
+    /**
+     * <p>One or more values that can be substituted in an expression.</p>
+     */
+    inline ConditionCheck& WithExpressionAttributeValues(Aws::Map<Aws::String, AttributeValue>&& value) { SetExpressionAttributeValues(std::move(value)); return *this;}
+
+    /**
+     * <p>One or more values that can be substituted in an expression.</p>
+     */
+    inline ConditionCheck& AddExpressionAttributeValues(const Aws::String& key, const AttributeValue& value) { m_expressionAttributeValuesHasBeenSet = true; m_expressionAttributeValues.emplace(key, value); return *this; }
+
+    /**
+     * <p>One or more values that can be substituted in an expression.</p>
+     */
+    inline ConditionCheck& AddExpressionAttributeValues(Aws::String&& key, const AttributeValue& value) { m_expressionAttributeValuesHasBeenSet = true; m_expressionAttributeValues.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>One or more values that can be substituted in an expression.</p>
+     */
+    inline ConditionCheck& AddExpressionAttributeValues(const Aws::String& key, AttributeValue&& value) { m_expressionAttributeValuesHasBeenSet = true; m_expressionAttributeValues.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>One or more values that can be substituted in an expression.</p>
+     */
+    inline ConditionCheck& AddExpressionAttributeValues(Aws::String&& key, AttributeValue&& value) { m_expressionAttributeValuesHasBeenSet = true; m_expressionAttributeValues.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>One or more values that can be substituted in an expression.</p>
+     */
+    inline ConditionCheck& AddExpressionAttributeValues(const char* key, AttributeValue&& value) { m_expressionAttributeValuesHasBeenSet = true; m_expressionAttributeValues.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>One or more values that can be substituted in an expression.</p>
+     */
+    inline ConditionCheck& AddExpressionAttributeValues(const char* key, const AttributeValue& value) { m_expressionAttributeValuesHasBeenSet = true; m_expressionAttributeValues.emplace(key, value); return *this; }
+
+
+    /**
+     * <p>Use <code>ReturnValuesOnConditionCheckFailure</code> to get the item
+     * attributes if the <code>ConditionCheck</code> condition fails. For
+     * <code>ReturnValuesOnConditionCheckFailure</code>, the valid values are: NONE and
+     * ALL_OLD.</p>
+     */
+    inline const ReturnValuesOnConditionCheckFailure& GetReturnValuesOnConditionCheckFailure() const{ return m_returnValuesOnConditionCheckFailure; }
+
+    /**
+     * <p>Use <code>ReturnValuesOnConditionCheckFailure</code> to get the item
+     * attributes if the <code>ConditionCheck</code> condition fails. For
+     * <code>ReturnValuesOnConditionCheckFailure</code>, the valid values are: NONE and
+     * ALL_OLD.</p>
+     */
+    inline bool ReturnValuesOnConditionCheckFailureHasBeenSet() const { return m_returnValuesOnConditionCheckFailureHasBeenSet; }
+
+    /**
+     * <p>Use <code>ReturnValuesOnConditionCheckFailure</code> to get the item
+     * attributes if the <code>ConditionCheck</code> condition fails. For
+     * <code>ReturnValuesOnConditionCheckFailure</code>, the valid values are: NONE and
+     * ALL_OLD.</p>
+     */
+    inline void SetReturnValuesOnConditionCheckFailure(const ReturnValuesOnConditionCheckFailure& value) { m_returnValuesOnConditionCheckFailureHasBeenSet = true; m_returnValuesOnConditionCheckFailure = value; }
+
+    /**
+     * <p>Use <code>ReturnValuesOnConditionCheckFailure</code> to get the item
+     * attributes if the <code>ConditionCheck</code> condition fails. For
+     * <code>ReturnValuesOnConditionCheckFailure</code>, the valid values are: NONE and
+     * ALL_OLD.</p>
+     */
+    inline void SetReturnValuesOnConditionCheckFailure(ReturnValuesOnConditionCheckFailure&& value) { m_returnValuesOnConditionCheckFailureHasBeenSet = true; m_returnValuesOnConditionCheckFailure = std::move(value); }
+
+    /**
+     * <p>Use <code>ReturnValuesOnConditionCheckFailure</code> to get the item
+     * attributes if the <code>ConditionCheck</code> condition fails. For
+     * <code>ReturnValuesOnConditionCheckFailure</code>, the valid values are: NONE and
+     * ALL_OLD.</p>
+     */
+    inline ConditionCheck& WithReturnValuesOnConditionCheckFailure(const ReturnValuesOnConditionCheckFailure& value) { SetReturnValuesOnConditionCheckFailure(value); return *this;}
+
+    /**
+     * <p>Use <code>ReturnValuesOnConditionCheckFailure</code> to get the item
+     * attributes if the <code>ConditionCheck</code> condition fails. For
+     * <code>ReturnValuesOnConditionCheckFailure</code>, the valid values are: NONE and
+     * ALL_OLD.</p>
+     */
+    inline ConditionCheck& WithReturnValuesOnConditionCheckFailure(ReturnValuesOnConditionCheckFailure&& value) { SetReturnValuesOnConditionCheckFailure(std::move(value)); return *this;}
+
+  private:
+
+    Aws::Map<Aws::String, AttributeValue> m_key;
+    bool m_keyHasBeenSet;
+
+    Aws::String m_tableName;
+    bool m_tableNameHasBeenSet;
+
+    Aws::String m_conditionExpression;
+    bool m_conditionExpressionHasBeenSet;
+
+    Aws::Map<Aws::String, Aws::String> m_expressionAttributeNames;
+    bool m_expressionAttributeNamesHasBeenSet;
+
+    Aws::Map<Aws::String, AttributeValue> m_expressionAttributeValues;
+    bool m_expressionAttributeValuesHasBeenSet;
+
+    ReturnValuesOnConditionCheckFailure m_returnValuesOnConditionCheckFailure;
+    bool m_returnValuesOnConditionCheckFailureHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/ConditionalOperator.h

@@ -0,0 +1,31 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+  enum class ConditionalOperator
+  {
+    NOT_SET,
+    AND,
+    OR
+  };
+
+namespace ConditionalOperatorMapper
+{
+AWS_DYNAMODB_API ConditionalOperator GetConditionalOperatorForName(const Aws::String& name);
+
+AWS_DYNAMODB_API Aws::String GetNameForConditionalOperator(ConditionalOperator value);
+} // namespace ConditionalOperatorMapper
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/ConsumedCapacity.h

@@ -0,0 +1,354 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/dynamodb/model/Capacity.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>The capacity units consumed by an operation. The data returned includes the
+   * total provisioned throughput consumed, along with statistics for the table and
+   * any indexes involved in the operation. <code>ConsumedCapacity</code> is only
+   * returned if the request asked for it. For more information, see <a
+   * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ProvisionedThroughputIntro.html">Provisioned
+   * Throughput</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ConsumedCapacity">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API ConsumedCapacity
+  {
+  public:
+    ConsumedCapacity();
+    ConsumedCapacity(Aws::Utils::Json::JsonView jsonValue);
+    ConsumedCapacity& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The name of the table that was affected by the operation.</p>
+     */
+    inline const Aws::String& GetTableName() const{ return m_tableName; }
+
+    /**
+     * <p>The name of the table that was affected by the operation.</p>
+     */
+    inline bool TableNameHasBeenSet() const { return m_tableNameHasBeenSet; }
+
+    /**
+     * <p>The name of the table that was affected by the operation.</p>
+     */
+    inline void SetTableName(const Aws::String& value) { m_tableNameHasBeenSet = true; m_tableName = value; }
+
+    /**
+     * <p>The name of the table that was affected by the operation.</p>
+     */
+    inline void SetTableName(Aws::String&& value) { m_tableNameHasBeenSet = true; m_tableName = std::move(value); }
+
+    /**
+     * <p>The name of the table that was affected by the operation.</p>
+     */
+    inline void SetTableName(const char* value) { m_tableNameHasBeenSet = true; m_tableName.assign(value); }
+
+    /**
+     * <p>The name of the table that was affected by the operation.</p>
+     */
+    inline ConsumedCapacity& WithTableName(const Aws::String& value) { SetTableName(value); return *this;}
+
+    /**
+     * <p>The name of the table that was affected by the operation.</p>
+     */
+    inline ConsumedCapacity& WithTableName(Aws::String&& value) { SetTableName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the table that was affected by the operation.</p>
+     */
+    inline ConsumedCapacity& WithTableName(const char* value) { SetTableName(value); return *this;}
+
+
+    /**
+     * <p>The total number of capacity units consumed by the operation.</p>
+     */
+    inline double GetCapacityUnits() const{ return m_capacityUnits; }
+
+    /**
+     * <p>The total number of capacity units consumed by the operation.</p>
+     */
+    inline bool CapacityUnitsHasBeenSet() const { return m_capacityUnitsHasBeenSet; }
+
+    /**
+     * <p>The total number of capacity units consumed by the operation.</p>
+     */
+    inline void SetCapacityUnits(double value) { m_capacityUnitsHasBeenSet = true; m_capacityUnits = value; }
+
+    /**
+     * <p>The total number of capacity units consumed by the operation.</p>
+     */
+    inline ConsumedCapacity& WithCapacityUnits(double value) { SetCapacityUnits(value); return *this;}
+
+
+    /**
+     * <p>The total number of read capacity units consumed by the operation.</p>
+     */
+    inline double GetReadCapacityUnits() const{ return m_readCapacityUnits; }
+
+    /**
+     * <p>The total number of read capacity units consumed by the operation.</p>
+     */
+    inline bool ReadCapacityUnitsHasBeenSet() const { return m_readCapacityUnitsHasBeenSet; }
+
+    /**
+     * <p>The total number of read capacity units consumed by the operation.</p>
+     */
+    inline void SetReadCapacityUnits(double value) { m_readCapacityUnitsHasBeenSet = true; m_readCapacityUnits = value; }
+
+    /**
+     * <p>The total number of read capacity units consumed by the operation.</p>
+     */
+    inline ConsumedCapacity& WithReadCapacityUnits(double value) { SetReadCapacityUnits(value); return *this;}
+
+
+    /**
+     * <p>The total number of write capacity units consumed by the operation.</p>
+     */
+    inline double GetWriteCapacityUnits() const{ return m_writeCapacityUnits; }
+
+    /**
+     * <p>The total number of write capacity units consumed by the operation.</p>
+     */
+    inline bool WriteCapacityUnitsHasBeenSet() const { return m_writeCapacityUnitsHasBeenSet; }
+
+    /**
+     * <p>The total number of write capacity units consumed by the operation.</p>
+     */
+    inline void SetWriteCapacityUnits(double value) { m_writeCapacityUnitsHasBeenSet = true; m_writeCapacityUnits = value; }
+
+    /**
+     * <p>The total number of write capacity units consumed by the operation.</p>
+     */
+    inline ConsumedCapacity& WithWriteCapacityUnits(double value) { SetWriteCapacityUnits(value); return *this;}
+
+
+    /**
+     * <p>The amount of throughput consumed on the table affected by the operation.</p>
+     */
+    inline const Capacity& GetTable() const{ return m_table; }
+
+    /**
+     * <p>The amount of throughput consumed on the table affected by the operation.</p>
+     */
+    inline bool TableHasBeenSet() const { return m_tableHasBeenSet; }
+
+    /**
+     * <p>The amount of throughput consumed on the table affected by the operation.</p>
+     */
+    inline void SetTable(const Capacity& value) { m_tableHasBeenSet = true; m_table = value; }
+
+    /**
+     * <p>The amount of throughput consumed on the table affected by the operation.</p>
+     */
+    inline void SetTable(Capacity&& value) { m_tableHasBeenSet = true; m_table = std::move(value); }
+
+    /**
+     * <p>The amount of throughput consumed on the table affected by the operation.</p>
+     */
+    inline ConsumedCapacity& WithTable(const Capacity& value) { SetTable(value); return *this;}
+
+    /**
+     * <p>The amount of throughput consumed on the table affected by the operation.</p>
+     */
+    inline ConsumedCapacity& WithTable(Capacity&& value) { SetTable(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The amount of throughput consumed on each local index affected by the
+     * operation.</p>
+     */
+    inline const Aws::Map<Aws::String, Capacity>& GetLocalSecondaryIndexes() const{ return m_localSecondaryIndexes; }
+
+    /**
+     * <p>The amount of throughput consumed on each local index affected by the
+     * operation.</p>
+     */
+    inline bool LocalSecondaryIndexesHasBeenSet() const { return m_localSecondaryIndexesHasBeenSet; }
+
+    /**
+     * <p>The amount of throughput consumed on each local index affected by the
+     * operation.</p>
+     */
+    inline void SetLocalSecondaryIndexes(const Aws::Map<Aws::String, Capacity>& value) { m_localSecondaryIndexesHasBeenSet = true; m_localSecondaryIndexes = value; }
+
+    /**
+     * <p>The amount of throughput consumed on each local index affected by the
+     * operation.</p>
+     */
+    inline void SetLocalSecondaryIndexes(Aws::Map<Aws::String, Capacity>&& value) { m_localSecondaryIndexesHasBeenSet = true; m_localSecondaryIndexes = std::move(value); }
+
+    /**
+     * <p>The amount of throughput consumed on each local index affected by the
+     * operation.</p>
+     */
+    inline ConsumedCapacity& WithLocalSecondaryIndexes(const Aws::Map<Aws::String, Capacity>& value) { SetLocalSecondaryIndexes(value); return *this;}
+
+    /**
+     * <p>The amount of throughput consumed on each local index affected by the
+     * operation.</p>
+     */
+    inline ConsumedCapacity& WithLocalSecondaryIndexes(Aws::Map<Aws::String, Capacity>&& value) { SetLocalSecondaryIndexes(std::move(value)); return *this;}
+
+    /**
+     * <p>The amount of throughput consumed on each local index affected by the
+     * operation.</p>
+     */
+    inline ConsumedCapacity& AddLocalSecondaryIndexes(const Aws::String& key, const Capacity& value) { m_localSecondaryIndexesHasBeenSet = true; m_localSecondaryIndexes.emplace(key, value); return *this; }
+
+    /**
+     * <p>The amount of throughput consumed on each local index affected by the
+     * operation.</p>
+     */
+    inline ConsumedCapacity& AddLocalSecondaryIndexes(Aws::String&& key, const Capacity& value) { m_localSecondaryIndexesHasBeenSet = true; m_localSecondaryIndexes.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>The amount of throughput consumed on each local index affected by the
+     * operation.</p>
+     */
+    inline ConsumedCapacity& AddLocalSecondaryIndexes(const Aws::String& key, Capacity&& value) { m_localSecondaryIndexesHasBeenSet = true; m_localSecondaryIndexes.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>The amount of throughput consumed on each local index affected by the
+     * operation.</p>
+     */
+    inline ConsumedCapacity& AddLocalSecondaryIndexes(Aws::String&& key, Capacity&& value) { m_localSecondaryIndexesHasBeenSet = true; m_localSecondaryIndexes.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>The amount of throughput consumed on each local index affected by the
+     * operation.</p>
+     */
+    inline ConsumedCapacity& AddLocalSecondaryIndexes(const char* key, Capacity&& value) { m_localSecondaryIndexesHasBeenSet = true; m_localSecondaryIndexes.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>The amount of throughput consumed on each local index affected by the
+     * operation.</p>
+     */
+    inline ConsumedCapacity& AddLocalSecondaryIndexes(const char* key, const Capacity& value) { m_localSecondaryIndexesHasBeenSet = true; m_localSecondaryIndexes.emplace(key, value); return *this; }
+
+
+    /**
+     * <p>The amount of throughput consumed on each global index affected by the
+     * operation.</p>
+     */
+    inline const Aws::Map<Aws::String, Capacity>& GetGlobalSecondaryIndexes() const{ return m_globalSecondaryIndexes; }
+
+    /**
+     * <p>The amount of throughput consumed on each global index affected by the
+     * operation.</p>
+     */
+    inline bool GlobalSecondaryIndexesHasBeenSet() const { return m_globalSecondaryIndexesHasBeenSet; }
+
+    /**
+     * <p>The amount of throughput consumed on each global index affected by the
+     * operation.</p>
+     */
+    inline void SetGlobalSecondaryIndexes(const Aws::Map<Aws::String, Capacity>& value) { m_globalSecondaryIndexesHasBeenSet = true; m_globalSecondaryIndexes = value; }
+
+    /**
+     * <p>The amount of throughput consumed on each global index affected by the
+     * operation.</p>
+     */
+    inline void SetGlobalSecondaryIndexes(Aws::Map<Aws::String, Capacity>&& value) { m_globalSecondaryIndexesHasBeenSet = true; m_globalSecondaryIndexes = std::move(value); }
+
+    /**
+     * <p>The amount of throughput consumed on each global index affected by the
+     * operation.</p>
+     */
+    inline ConsumedCapacity& WithGlobalSecondaryIndexes(const Aws::Map<Aws::String, Capacity>& value) { SetGlobalSecondaryIndexes(value); return *this;}
+
+    /**
+     * <p>The amount of throughput consumed on each global index affected by the
+     * operation.</p>
+     */
+    inline ConsumedCapacity& WithGlobalSecondaryIndexes(Aws::Map<Aws::String, Capacity>&& value) { SetGlobalSecondaryIndexes(std::move(value)); return *this;}
+
+    /**
+     * <p>The amount of throughput consumed on each global index affected by the
+     * operation.</p>
+     */
+    inline ConsumedCapacity& AddGlobalSecondaryIndexes(const Aws::String& key, const Capacity& value) { m_globalSecondaryIndexesHasBeenSet = true; m_globalSecondaryIndexes.emplace(key, value); return *this; }
+
+    /**
+     * <p>The amount of throughput consumed on each global index affected by the
+     * operation.</p>
+     */
+    inline ConsumedCapacity& AddGlobalSecondaryIndexes(Aws::String&& key, const Capacity& value) { m_globalSecondaryIndexesHasBeenSet = true; m_globalSecondaryIndexes.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>The amount of throughput consumed on each global index affected by the
+     * operation.</p>
+     */
+    inline ConsumedCapacity& AddGlobalSecondaryIndexes(const Aws::String& key, Capacity&& value) { m_globalSecondaryIndexesHasBeenSet = true; m_globalSecondaryIndexes.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>The amount of throughput consumed on each global index affected by the
+     * operation.</p>
+     */
+    inline ConsumedCapacity& AddGlobalSecondaryIndexes(Aws::String&& key, Capacity&& value) { m_globalSecondaryIndexesHasBeenSet = true; m_globalSecondaryIndexes.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>The amount of throughput consumed on each global index affected by the
+     * operation.</p>
+     */
+    inline ConsumedCapacity& AddGlobalSecondaryIndexes(const char* key, Capacity&& value) { m_globalSecondaryIndexesHasBeenSet = true; m_globalSecondaryIndexes.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>The amount of throughput consumed on each global index affected by the
+     * operation.</p>
+     */
+    inline ConsumedCapacity& AddGlobalSecondaryIndexes(const char* key, const Capacity& value) { m_globalSecondaryIndexesHasBeenSet = true; m_globalSecondaryIndexes.emplace(key, value); return *this; }
+
+  private:
+
+    Aws::String m_tableName;
+    bool m_tableNameHasBeenSet;
+
+    double m_capacityUnits;
+    bool m_capacityUnitsHasBeenSet;
+
+    double m_readCapacityUnits;
+    bool m_readCapacityUnitsHasBeenSet;
+
+    double m_writeCapacityUnits;
+    bool m_writeCapacityUnitsHasBeenSet;
+
+    Capacity m_table;
+    bool m_tableHasBeenSet;
+
+    Aws::Map<Aws::String, Capacity> m_localSecondaryIndexes;
+    bool m_localSecondaryIndexesHasBeenSet;
+
+    Aws::Map<Aws::String, Capacity> m_globalSecondaryIndexes;
+    bool m_globalSecondaryIndexesHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/ContinuousBackupsDescription.h

@@ -0,0 +1,126 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/model/ContinuousBackupsStatus.h>
+#include <aws/dynamodb/model/PointInTimeRecoveryDescription.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents the continuous backups and point in time recovery settings on the
+   * table.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ContinuousBackupsDescription">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API ContinuousBackupsDescription
+  {
+  public:
+    ContinuousBackupsDescription();
+    ContinuousBackupsDescription(Aws::Utils::Json::JsonView jsonValue);
+    ContinuousBackupsDescription& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p> <code>ContinuousBackupsStatus</code> can be one of the following states:
+     * ENABLED, DISABLED</p>
+     */
+    inline const ContinuousBackupsStatus& GetContinuousBackupsStatus() const{ return m_continuousBackupsStatus; }
+
+    /**
+     * <p> <code>ContinuousBackupsStatus</code> can be one of the following states:
+     * ENABLED, DISABLED</p>
+     */
+    inline bool ContinuousBackupsStatusHasBeenSet() const { return m_continuousBackupsStatusHasBeenSet; }
+
+    /**
+     * <p> <code>ContinuousBackupsStatus</code> can be one of the following states:
+     * ENABLED, DISABLED</p>
+     */
+    inline void SetContinuousBackupsStatus(const ContinuousBackupsStatus& value) { m_continuousBackupsStatusHasBeenSet = true; m_continuousBackupsStatus = value; }
+
+    /**
+     * <p> <code>ContinuousBackupsStatus</code> can be one of the following states:
+     * ENABLED, DISABLED</p>
+     */
+    inline void SetContinuousBackupsStatus(ContinuousBackupsStatus&& value) { m_continuousBackupsStatusHasBeenSet = true; m_continuousBackupsStatus = std::move(value); }
+
+    /**
+     * <p> <code>ContinuousBackupsStatus</code> can be one of the following states:
+     * ENABLED, DISABLED</p>
+     */
+    inline ContinuousBackupsDescription& WithContinuousBackupsStatus(const ContinuousBackupsStatus& value) { SetContinuousBackupsStatus(value); return *this;}
+
+    /**
+     * <p> <code>ContinuousBackupsStatus</code> can be one of the following states:
+     * ENABLED, DISABLED</p>
+     */
+    inline ContinuousBackupsDescription& WithContinuousBackupsStatus(ContinuousBackupsStatus&& value) { SetContinuousBackupsStatus(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The description of the point in time recovery settings applied to the
+     * table.</p>
+     */
+    inline const PointInTimeRecoveryDescription& GetPointInTimeRecoveryDescription() const{ return m_pointInTimeRecoveryDescription; }
+
+    /**
+     * <p>The description of the point in time recovery settings applied to the
+     * table.</p>
+     */
+    inline bool PointInTimeRecoveryDescriptionHasBeenSet() const { return m_pointInTimeRecoveryDescriptionHasBeenSet; }
+
+    /**
+     * <p>The description of the point in time recovery settings applied to the
+     * table.</p>
+     */
+    inline void SetPointInTimeRecoveryDescription(const PointInTimeRecoveryDescription& value) { m_pointInTimeRecoveryDescriptionHasBeenSet = true; m_pointInTimeRecoveryDescription = value; }
+
+    /**
+     * <p>The description of the point in time recovery settings applied to the
+     * table.</p>
+     */
+    inline void SetPointInTimeRecoveryDescription(PointInTimeRecoveryDescription&& value) { m_pointInTimeRecoveryDescriptionHasBeenSet = true; m_pointInTimeRecoveryDescription = std::move(value); }
+
+    /**
+     * <p>The description of the point in time recovery settings applied to the
+     * table.</p>
+     */
+    inline ContinuousBackupsDescription& WithPointInTimeRecoveryDescription(const PointInTimeRecoveryDescription& value) { SetPointInTimeRecoveryDescription(value); return *this;}
+
+    /**
+     * <p>The description of the point in time recovery settings applied to the
+     * table.</p>
+     */
+    inline ContinuousBackupsDescription& WithPointInTimeRecoveryDescription(PointInTimeRecoveryDescription&& value) { SetPointInTimeRecoveryDescription(std::move(value)); return *this;}
+
+  private:
+
+    ContinuousBackupsStatus m_continuousBackupsStatus;
+    bool m_continuousBackupsStatusHasBeenSet;
+
+    PointInTimeRecoveryDescription m_pointInTimeRecoveryDescription;
+    bool m_pointInTimeRecoveryDescriptionHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/ContinuousBackupsStatus.h

@@ -0,0 +1,31 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+  enum class ContinuousBackupsStatus
+  {
+    NOT_SET,
+    ENABLED,
+    DISABLED
+  };
+
+namespace ContinuousBackupsStatusMapper
+{
+AWS_DYNAMODB_API ContinuousBackupsStatus GetContinuousBackupsStatusForName(const Aws::String& name);
+
+AWS_DYNAMODB_API Aws::String GetNameForContinuousBackupsStatus(ContinuousBackupsStatus value);
+} // namespace ContinuousBackupsStatusMapper
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/ContributorInsightsAction.h

@@ -0,0 +1,31 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+  enum class ContributorInsightsAction
+  {
+    NOT_SET,
+    ENABLE,
+    DISABLE
+  };
+
+namespace ContributorInsightsActionMapper
+{
+AWS_DYNAMODB_API ContributorInsightsAction GetContributorInsightsActionForName(const Aws::String& name);
+
+AWS_DYNAMODB_API Aws::String GetNameForContributorInsightsAction(ContributorInsightsAction value);
+} // namespace ContributorInsightsActionMapper
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/ContributorInsightsStatus.h

@@ -0,0 +1,34 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+  enum class ContributorInsightsStatus
+  {
+    NOT_SET,
+    ENABLING,
+    ENABLED,
+    DISABLING,
+    DISABLED,
+    FAILED
+  };
+
+namespace ContributorInsightsStatusMapper
+{
+AWS_DYNAMODB_API ContributorInsightsStatus GetContributorInsightsStatusForName(const Aws::String& name);
+
+AWS_DYNAMODB_API Aws::String GetNameForContributorInsightsStatus(ContributorInsightsStatus value);
+} // namespace ContributorInsightsStatusMapper
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/ContributorInsightsSummary.h

@@ -0,0 +1,174 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/dynamodb/model/ContributorInsightsStatus.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents a Contributor Insights summary entry..</p><p><h3>See Also:</h3>  
+   * <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ContributorInsightsSummary">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API ContributorInsightsSummary
+  {
+  public:
+    ContributorInsightsSummary();
+    ContributorInsightsSummary(Aws::Utils::Json::JsonView jsonValue);
+    ContributorInsightsSummary& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Name of the table associated with the summary.</p>
+     */
+    inline const Aws::String& GetTableName() const{ return m_tableName; }
+
+    /**
+     * <p>Name of the table associated with the summary.</p>
+     */
+    inline bool TableNameHasBeenSet() const { return m_tableNameHasBeenSet; }
+
+    /**
+     * <p>Name of the table associated with the summary.</p>
+     */
+    inline void SetTableName(const Aws::String& value) { m_tableNameHasBeenSet = true; m_tableName = value; }
+
+    /**
+     * <p>Name of the table associated with the summary.</p>
+     */
+    inline void SetTableName(Aws::String&& value) { m_tableNameHasBeenSet = true; m_tableName = std::move(value); }
+
+    /**
+     * <p>Name of the table associated with the summary.</p>
+     */
+    inline void SetTableName(const char* value) { m_tableNameHasBeenSet = true; m_tableName.assign(value); }
+
+    /**
+     * <p>Name of the table associated with the summary.</p>
+     */
+    inline ContributorInsightsSummary& WithTableName(const Aws::String& value) { SetTableName(value); return *this;}
+
+    /**
+     * <p>Name of the table associated with the summary.</p>
+     */
+    inline ContributorInsightsSummary& WithTableName(Aws::String&& value) { SetTableName(std::move(value)); return *this;}
+
+    /**
+     * <p>Name of the table associated with the summary.</p>
+     */
+    inline ContributorInsightsSummary& WithTableName(const char* value) { SetTableName(value); return *this;}
+
+
+    /**
+     * <p>Name of the index associated with the summary, if any.</p>
+     */
+    inline const Aws::String& GetIndexName() const{ return m_indexName; }
+
+    /**
+     * <p>Name of the index associated with the summary, if any.</p>
+     */
+    inline bool IndexNameHasBeenSet() const { return m_indexNameHasBeenSet; }
+
+    /**
+     * <p>Name of the index associated with the summary, if any.</p>
+     */
+    inline void SetIndexName(const Aws::String& value) { m_indexNameHasBeenSet = true; m_indexName = value; }
+
+    /**
+     * <p>Name of the index associated with the summary, if any.</p>
+     */
+    inline void SetIndexName(Aws::String&& value) { m_indexNameHasBeenSet = true; m_indexName = std::move(value); }
+
+    /**
+     * <p>Name of the index associated with the summary, if any.</p>
+     */
+    inline void SetIndexName(const char* value) { m_indexNameHasBeenSet = true; m_indexName.assign(value); }
+
+    /**
+     * <p>Name of the index associated with the summary, if any.</p>
+     */
+    inline ContributorInsightsSummary& WithIndexName(const Aws::String& value) { SetIndexName(value); return *this;}
+
+    /**
+     * <p>Name of the index associated with the summary, if any.</p>
+     */
+    inline ContributorInsightsSummary& WithIndexName(Aws::String&& value) { SetIndexName(std::move(value)); return *this;}
+
+    /**
+     * <p>Name of the index associated with the summary, if any.</p>
+     */
+    inline ContributorInsightsSummary& WithIndexName(const char* value) { SetIndexName(value); return *this;}
+
+
+    /**
+     * <p>Describes the current status for contributor insights for the given table and
+     * index, if applicable.</p>
+     */
+    inline const ContributorInsightsStatus& GetContributorInsightsStatus() const{ return m_contributorInsightsStatus; }
+
+    /**
+     * <p>Describes the current status for contributor insights for the given table and
+     * index, if applicable.</p>
+     */
+    inline bool ContributorInsightsStatusHasBeenSet() const { return m_contributorInsightsStatusHasBeenSet; }
+
+    /**
+     * <p>Describes the current status for contributor insights for the given table and
+     * index, if applicable.</p>
+     */
+    inline void SetContributorInsightsStatus(const ContributorInsightsStatus& value) { m_contributorInsightsStatusHasBeenSet = true; m_contributorInsightsStatus = value; }
+
+    /**
+     * <p>Describes the current status for contributor insights for the given table and
+     * index, if applicable.</p>
+     */
+    inline void SetContributorInsightsStatus(ContributorInsightsStatus&& value) { m_contributorInsightsStatusHasBeenSet = true; m_contributorInsightsStatus = std::move(value); }
+
+    /**
+     * <p>Describes the current status for contributor insights for the given table and
+     * index, if applicable.</p>
+     */
+    inline ContributorInsightsSummary& WithContributorInsightsStatus(const ContributorInsightsStatus& value) { SetContributorInsightsStatus(value); return *this;}
+
+    /**
+     * <p>Describes the current status for contributor insights for the given table and
+     * index, if applicable.</p>
+     */
+    inline ContributorInsightsSummary& WithContributorInsightsStatus(ContributorInsightsStatus&& value) { SetContributorInsightsStatus(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_tableName;
+    bool m_tableNameHasBeenSet;
+
+    Aws::String m_indexName;
+    bool m_indexNameHasBeenSet;
+
+    ContributorInsightsStatus m_contributorInsightsStatus;
+    bool m_contributorInsightsStatusHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/CreateBackupRequest.h

@@ -0,0 +1,129 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/DynamoDBRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DYNAMODB_API CreateBackupRequest : public DynamoDBRequest
+  {
+  public:
+    CreateBackupRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "CreateBackup"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the table.</p>
+     */
+    inline const Aws::String& GetTableName() const{ return m_tableName; }
+
+    /**
+     * <p>The name of the table.</p>
+     */
+    inline bool TableNameHasBeenSet() const { return m_tableNameHasBeenSet; }
+
+    /**
+     * <p>The name of the table.</p>
+     */
+    inline void SetTableName(const Aws::String& value) { m_tableNameHasBeenSet = true; m_tableName = value; }
+
+    /**
+     * <p>The name of the table.</p>
+     */
+    inline void SetTableName(Aws::String&& value) { m_tableNameHasBeenSet = true; m_tableName = std::move(value); }
+
+    /**
+     * <p>The name of the table.</p>
+     */
+    inline void SetTableName(const char* value) { m_tableNameHasBeenSet = true; m_tableName.assign(value); }
+
+    /**
+     * <p>The name of the table.</p>
+     */
+    inline CreateBackupRequest& WithTableName(const Aws::String& value) { SetTableName(value); return *this;}
+
+    /**
+     * <p>The name of the table.</p>
+     */
+    inline CreateBackupRequest& WithTableName(Aws::String&& value) { SetTableName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the table.</p>
+     */
+    inline CreateBackupRequest& WithTableName(const char* value) { SetTableName(value); return *this;}
+
+
+    /**
+     * <p>Specified name for the backup.</p>
+     */
+    inline const Aws::String& GetBackupName() const{ return m_backupName; }
+
+    /**
+     * <p>Specified name for the backup.</p>
+     */
+    inline bool BackupNameHasBeenSet() const { return m_backupNameHasBeenSet; }
+
+    /**
+     * <p>Specified name for the backup.</p>
+     */
+    inline void SetBackupName(const Aws::String& value) { m_backupNameHasBeenSet = true; m_backupName = value; }
+
+    /**
+     * <p>Specified name for the backup.</p>
+     */
+    inline void SetBackupName(Aws::String&& value) { m_backupNameHasBeenSet = true; m_backupName = std::move(value); }
+
+    /**
+     * <p>Specified name for the backup.</p>
+     */
+    inline void SetBackupName(const char* value) { m_backupNameHasBeenSet = true; m_backupName.assign(value); }
+
+    /**
+     * <p>Specified name for the backup.</p>
+     */
+    inline CreateBackupRequest& WithBackupName(const Aws::String& value) { SetBackupName(value); return *this;}
+
+    /**
+     * <p>Specified name for the backup.</p>
+     */
+    inline CreateBackupRequest& WithBackupName(Aws::String&& value) { SetBackupName(std::move(value)); return *this;}
+
+    /**
+     * <p>Specified name for the backup.</p>
+     */
+    inline CreateBackupRequest& WithBackupName(const char* value) { SetBackupName(value); return *this;}
+
+  private:
+
+    Aws::String m_tableName;
+    bool m_tableNameHasBeenSet;
+
+    Aws::String m_backupName;
+    bool m_backupNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/CreateBackupResult.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/model/BackupDetails.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+  class AWS_DYNAMODB_API CreateBackupResult
+  {
+  public:
+    CreateBackupResult();
+    CreateBackupResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    CreateBackupResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Contains the details of the backup created for the table.</p>
+     */
+    inline const BackupDetails& GetBackupDetails() const{ return m_backupDetails; }
+
+    /**
+     * <p>Contains the details of the backup created for the table.</p>
+     */
+    inline void SetBackupDetails(const BackupDetails& value) { m_backupDetails = value; }
+
+    /**
+     * <p>Contains the details of the backup created for the table.</p>
+     */
+    inline void SetBackupDetails(BackupDetails&& value) { m_backupDetails = std::move(value); }
+
+    /**
+     * <p>Contains the details of the backup created for the table.</p>
+     */
+    inline CreateBackupResult& WithBackupDetails(const BackupDetails& value) { SetBackupDetails(value); return *this;}
+
+    /**
+     * <p>Contains the details of the backup created for the table.</p>
+     */
+    inline CreateBackupResult& WithBackupDetails(BackupDetails&& value) { SetBackupDetails(std::move(value)); return *this;}
+
+  private:
+
+    BackupDetails m_backupDetails;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/CreateGlobalSecondaryIndexAction.h

@@ -0,0 +1,241 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/dynamodb/model/Projection.h>
+#include <aws/dynamodb/model/ProvisionedThroughput.h>
+#include <aws/dynamodb/model/KeySchemaElement.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents a new global secondary index to be added to an existing
+   * table.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/CreateGlobalSecondaryIndexAction">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API CreateGlobalSecondaryIndexAction
+  {
+  public:
+    CreateGlobalSecondaryIndexAction();
+    CreateGlobalSecondaryIndexAction(Aws::Utils::Json::JsonView jsonValue);
+    CreateGlobalSecondaryIndexAction& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The name of the global secondary index to be created.</p>
+     */
+    inline const Aws::String& GetIndexName() const{ return m_indexName; }
+
+    /**
+     * <p>The name of the global secondary index to be created.</p>
+     */
+    inline bool IndexNameHasBeenSet() const { return m_indexNameHasBeenSet; }
+
+    /**
+     * <p>The name of the global secondary index to be created.</p>
+     */
+    inline void SetIndexName(const Aws::String& value) { m_indexNameHasBeenSet = true; m_indexName = value; }
+
+    /**
+     * <p>The name of the global secondary index to be created.</p>
+     */
+    inline void SetIndexName(Aws::String&& value) { m_indexNameHasBeenSet = true; m_indexName = std::move(value); }
+
+    /**
+     * <p>The name of the global secondary index to be created.</p>
+     */
+    inline void SetIndexName(const char* value) { m_indexNameHasBeenSet = true; m_indexName.assign(value); }
+
+    /**
+     * <p>The name of the global secondary index to be created.</p>
+     */
+    inline CreateGlobalSecondaryIndexAction& WithIndexName(const Aws::String& value) { SetIndexName(value); return *this;}
+
+    /**
+     * <p>The name of the global secondary index to be created.</p>
+     */
+    inline CreateGlobalSecondaryIndexAction& WithIndexName(Aws::String&& value) { SetIndexName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the global secondary index to be created.</p>
+     */
+    inline CreateGlobalSecondaryIndexAction& WithIndexName(const char* value) { SetIndexName(value); return *this;}
+
+
+    /**
+     * <p>The key schema for the global secondary index.</p>
+     */
+    inline const Aws::Vector<KeySchemaElement>& GetKeySchema() const{ return m_keySchema; }
+
+    /**
+     * <p>The key schema for the global secondary index.</p>
+     */
+    inline bool KeySchemaHasBeenSet() const { return m_keySchemaHasBeenSet; }
+
+    /**
+     * <p>The key schema for the global secondary index.</p>
+     */
+    inline void SetKeySchema(const Aws::Vector<KeySchemaElement>& value) { m_keySchemaHasBeenSet = true; m_keySchema = value; }
+
+    /**
+     * <p>The key schema for the global secondary index.</p>
+     */
+    inline void SetKeySchema(Aws::Vector<KeySchemaElement>&& value) { m_keySchemaHasBeenSet = true; m_keySchema = std::move(value); }
+
+    /**
+     * <p>The key schema for the global secondary index.</p>
+     */
+    inline CreateGlobalSecondaryIndexAction& WithKeySchema(const Aws::Vector<KeySchemaElement>& value) { SetKeySchema(value); return *this;}
+
+    /**
+     * <p>The key schema for the global secondary index.</p>
+     */
+    inline CreateGlobalSecondaryIndexAction& WithKeySchema(Aws::Vector<KeySchemaElement>&& value) { SetKeySchema(std::move(value)); return *this;}
+
+    /**
+     * <p>The key schema for the global secondary index.</p>
+     */
+    inline CreateGlobalSecondaryIndexAction& AddKeySchema(const KeySchemaElement& value) { m_keySchemaHasBeenSet = true; m_keySchema.push_back(value); return *this; }
+
+    /**
+     * <p>The key schema for the global secondary index.</p>
+     */
+    inline CreateGlobalSecondaryIndexAction& AddKeySchema(KeySchemaElement&& value) { m_keySchemaHasBeenSet = true; m_keySchema.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>Represents attributes that are copied (projected) from the table into an
+     * index. These are in addition to the primary key attributes and index key
+     * attributes, which are automatically projected.</p>
+     */
+    inline const Projection& GetProjection() const{ return m_projection; }
+
+    /**
+     * <p>Represents attributes that are copied (projected) from the table into an
+     * index. These are in addition to the primary key attributes and index key
+     * attributes, which are automatically projected.</p>
+     */
+    inline bool ProjectionHasBeenSet() const { return m_projectionHasBeenSet; }
+
+    /**
+     * <p>Represents attributes that are copied (projected) from the table into an
+     * index. These are in addition to the primary key attributes and index key
+     * attributes, which are automatically projected.</p>
+     */
+    inline void SetProjection(const Projection& value) { m_projectionHasBeenSet = true; m_projection = value; }
+
+    /**
+     * <p>Represents attributes that are copied (projected) from the table into an
+     * index. These are in addition to the primary key attributes and index key
+     * attributes, which are automatically projected.</p>
+     */
+    inline void SetProjection(Projection&& value) { m_projectionHasBeenSet = true; m_projection = std::move(value); }
+
+    /**
+     * <p>Represents attributes that are copied (projected) from the table into an
+     * index. These are in addition to the primary key attributes and index key
+     * attributes, which are automatically projected.</p>
+     */
+    inline CreateGlobalSecondaryIndexAction& WithProjection(const Projection& value) { SetProjection(value); return *this;}
+
+    /**
+     * <p>Represents attributes that are copied (projected) from the table into an
+     * index. These are in addition to the primary key attributes and index key
+     * attributes, which are automatically projected.</p>
+     */
+    inline CreateGlobalSecondaryIndexAction& WithProjection(Projection&& value) { SetProjection(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Represents the provisioned throughput settings for the specified global
+     * secondary index.</p> <p>For current minimum and maximum provisioned throughput
+     * values, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html">Limits</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline const ProvisionedThroughput& GetProvisionedThroughput() const{ return m_provisionedThroughput; }
+
+    /**
+     * <p>Represents the provisioned throughput settings for the specified global
+     * secondary index.</p> <p>For current minimum and maximum provisioned throughput
+     * values, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html">Limits</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline bool ProvisionedThroughputHasBeenSet() const { return m_provisionedThroughputHasBeenSet; }
+
+    /**
+     * <p>Represents the provisioned throughput settings for the specified global
+     * secondary index.</p> <p>For current minimum and maximum provisioned throughput
+     * values, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html">Limits</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline void SetProvisionedThroughput(const ProvisionedThroughput& value) { m_provisionedThroughputHasBeenSet = true; m_provisionedThroughput = value; }
+
+    /**
+     * <p>Represents the provisioned throughput settings for the specified global
+     * secondary index.</p> <p>For current minimum and maximum provisioned throughput
+     * values, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html">Limits</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline void SetProvisionedThroughput(ProvisionedThroughput&& value) { m_provisionedThroughputHasBeenSet = true; m_provisionedThroughput = std::move(value); }
+
+    /**
+     * <p>Represents the provisioned throughput settings for the specified global
+     * secondary index.</p> <p>For current minimum and maximum provisioned throughput
+     * values, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html">Limits</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline CreateGlobalSecondaryIndexAction& WithProvisionedThroughput(const ProvisionedThroughput& value) { SetProvisionedThroughput(value); return *this;}
+
+    /**
+     * <p>Represents the provisioned throughput settings for the specified global
+     * secondary index.</p> <p>For current minimum and maximum provisioned throughput
+     * values, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html">Limits</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline CreateGlobalSecondaryIndexAction& WithProvisionedThroughput(ProvisionedThroughput&& value) { SetProvisionedThroughput(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_indexName;
+    bool m_indexNameHasBeenSet;
+
+    Aws::Vector<KeySchemaElement> m_keySchema;
+    bool m_keySchemaHasBeenSet;
+
+    Projection m_projection;
+    bool m_projectionHasBeenSet;
+
+    ProvisionedThroughput m_provisionedThroughput;
+    bool m_provisionedThroughputHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/CreateGlobalTableRequest.h

@@ -0,0 +1,131 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/DynamoDBRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/dynamodb/model/Replica.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DYNAMODB_API CreateGlobalTableRequest : public DynamoDBRequest
+  {
+  public:
+    CreateGlobalTableRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "CreateGlobalTable"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The global table name.</p>
+     */
+    inline const Aws::String& GetGlobalTableName() const{ return m_globalTableName; }
+
+    /**
+     * <p>The global table name.</p>
+     */
+    inline bool GlobalTableNameHasBeenSet() const { return m_globalTableNameHasBeenSet; }
+
+    /**
+     * <p>The global table name.</p>
+     */
+    inline void SetGlobalTableName(const Aws::String& value) { m_globalTableNameHasBeenSet = true; m_globalTableName = value; }
+
+    /**
+     * <p>The global table name.</p>
+     */
+    inline void SetGlobalTableName(Aws::String&& value) { m_globalTableNameHasBeenSet = true; m_globalTableName = std::move(value); }
+
+    /**
+     * <p>The global table name.</p>
+     */
+    inline void SetGlobalTableName(const char* value) { m_globalTableNameHasBeenSet = true; m_globalTableName.assign(value); }
+
+    /**
+     * <p>The global table name.</p>
+     */
+    inline CreateGlobalTableRequest& WithGlobalTableName(const Aws::String& value) { SetGlobalTableName(value); return *this;}
+
+    /**
+     * <p>The global table name.</p>
+     */
+    inline CreateGlobalTableRequest& WithGlobalTableName(Aws::String&& value) { SetGlobalTableName(std::move(value)); return *this;}
+
+    /**
+     * <p>The global table name.</p>
+     */
+    inline CreateGlobalTableRequest& WithGlobalTableName(const char* value) { SetGlobalTableName(value); return *this;}
+
+
+    /**
+     * <p>The Regions where the global table needs to be created.</p>
+     */
+    inline const Aws::Vector<Replica>& GetReplicationGroup() const{ return m_replicationGroup; }
+
+    /**
+     * <p>The Regions where the global table needs to be created.</p>
+     */
+    inline bool ReplicationGroupHasBeenSet() const { return m_replicationGroupHasBeenSet; }
+
+    /**
+     * <p>The Regions where the global table needs to be created.</p>
+     */
+    inline void SetReplicationGroup(const Aws::Vector<Replica>& value) { m_replicationGroupHasBeenSet = true; m_replicationGroup = value; }
+
+    /**
+     * <p>The Regions where the global table needs to be created.</p>
+     */
+    inline void SetReplicationGroup(Aws::Vector<Replica>&& value) { m_replicationGroupHasBeenSet = true; m_replicationGroup = std::move(value); }
+
+    /**
+     * <p>The Regions where the global table needs to be created.</p>
+     */
+    inline CreateGlobalTableRequest& WithReplicationGroup(const Aws::Vector<Replica>& value) { SetReplicationGroup(value); return *this;}
+
+    /**
+     * <p>The Regions where the global table needs to be created.</p>
+     */
+    inline CreateGlobalTableRequest& WithReplicationGroup(Aws::Vector<Replica>&& value) { SetReplicationGroup(std::move(value)); return *this;}
+
+    /**
+     * <p>The Regions where the global table needs to be created.</p>
+     */
+    inline CreateGlobalTableRequest& AddReplicationGroup(const Replica& value) { m_replicationGroupHasBeenSet = true; m_replicationGroup.push_back(value); return *this; }
+
+    /**
+     * <p>The Regions where the global table needs to be created.</p>
+     */
+    inline CreateGlobalTableRequest& AddReplicationGroup(Replica&& value) { m_replicationGroupHasBeenSet = true; m_replicationGroup.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_globalTableName;
+    bool m_globalTableNameHasBeenSet;
+
+    Aws::Vector<Replica> m_replicationGroup;
+    bool m_replicationGroupHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/CreateGlobalTableResult.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/model/GlobalTableDescription.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+  class AWS_DYNAMODB_API CreateGlobalTableResult
+  {
+  public:
+    CreateGlobalTableResult();
+    CreateGlobalTableResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    CreateGlobalTableResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Contains the details of the global table.</p>
+     */
+    inline const GlobalTableDescription& GetGlobalTableDescription() const{ return m_globalTableDescription; }
+
+    /**
+     * <p>Contains the details of the global table.</p>
+     */
+    inline void SetGlobalTableDescription(const GlobalTableDescription& value) { m_globalTableDescription = value; }
+
+    /**
+     * <p>Contains the details of the global table.</p>
+     */
+    inline void SetGlobalTableDescription(GlobalTableDescription&& value) { m_globalTableDescription = std::move(value); }
+
+    /**
+     * <p>Contains the details of the global table.</p>
+     */
+    inline CreateGlobalTableResult& WithGlobalTableDescription(const GlobalTableDescription& value) { SetGlobalTableDescription(value); return *this;}
+
+    /**
+     * <p>Contains the details of the global table.</p>
+     */
+    inline CreateGlobalTableResult& WithGlobalTableDescription(GlobalTableDescription&& value) { SetGlobalTableDescription(std::move(value)); return *this;}
+
+  private:
+
+    GlobalTableDescription m_globalTableDescription;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/CreateReplicaAction.h

@@ -0,0 +1,88 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents a replica to be added.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/CreateReplicaAction">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API CreateReplicaAction
+  {
+  public:
+    CreateReplicaAction();
+    CreateReplicaAction(Aws::Utils::Json::JsonView jsonValue);
+    CreateReplicaAction& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The Region of the replica to be added.</p>
+     */
+    inline const Aws::String& GetRegionName() const{ return m_regionName; }
+
+    /**
+     * <p>The Region of the replica to be added.</p>
+     */
+    inline bool RegionNameHasBeenSet() const { return m_regionNameHasBeenSet; }
+
+    /**
+     * <p>The Region of the replica to be added.</p>
+     */
+    inline void SetRegionName(const Aws::String& value) { m_regionNameHasBeenSet = true; m_regionName = value; }
+
+    /**
+     * <p>The Region of the replica to be added.</p>
+     */
+    inline void SetRegionName(Aws::String&& value) { m_regionNameHasBeenSet = true; m_regionName = std::move(value); }
+
+    /**
+     * <p>The Region of the replica to be added.</p>
+     */
+    inline void SetRegionName(const char* value) { m_regionNameHasBeenSet = true; m_regionName.assign(value); }
+
+    /**
+     * <p>The Region of the replica to be added.</p>
+     */
+    inline CreateReplicaAction& WithRegionName(const Aws::String& value) { SetRegionName(value); return *this;}
+
+    /**
+     * <p>The Region of the replica to be added.</p>
+     */
+    inline CreateReplicaAction& WithRegionName(Aws::String&& value) { SetRegionName(std::move(value)); return *this;}
+
+    /**
+     * <p>The Region of the replica to be added.</p>
+     */
+    inline CreateReplicaAction& WithRegionName(const char* value) { SetRegionName(value); return *this;}
+
+  private:
+
+    Aws::String m_regionName;
+    bool m_regionNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/CreateReplicationGroupMemberAction.h

@@ -0,0 +1,251 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/dynamodb/model/ProvisionedThroughputOverride.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/dynamodb/model/ReplicaGlobalSecondaryIndex.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents a replica to be created.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/CreateReplicationGroupMemberAction">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API CreateReplicationGroupMemberAction
+  {
+  public:
+    CreateReplicationGroupMemberAction();
+    CreateReplicationGroupMemberAction(Aws::Utils::Json::JsonView jsonValue);
+    CreateReplicationGroupMemberAction& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The Region where the new replica will be created.</p>
+     */
+    inline const Aws::String& GetRegionName() const{ return m_regionName; }
+
+    /**
+     * <p>The Region where the new replica will be created.</p>
+     */
+    inline bool RegionNameHasBeenSet() const { return m_regionNameHasBeenSet; }
+
+    /**
+     * <p>The Region where the new replica will be created.</p>
+     */
+    inline void SetRegionName(const Aws::String& value) { m_regionNameHasBeenSet = true; m_regionName = value; }
+
+    /**
+     * <p>The Region where the new replica will be created.</p>
+     */
+    inline void SetRegionName(Aws::String&& value) { m_regionNameHasBeenSet = true; m_regionName = std::move(value); }
+
+    /**
+     * <p>The Region where the new replica will be created.</p>
+     */
+    inline void SetRegionName(const char* value) { m_regionNameHasBeenSet = true; m_regionName.assign(value); }
+
+    /**
+     * <p>The Region where the new replica will be created.</p>
+     */
+    inline CreateReplicationGroupMemberAction& WithRegionName(const Aws::String& value) { SetRegionName(value); return *this;}
+
+    /**
+     * <p>The Region where the new replica will be created.</p>
+     */
+    inline CreateReplicationGroupMemberAction& WithRegionName(Aws::String&& value) { SetRegionName(std::move(value)); return *this;}
+
+    /**
+     * <p>The Region where the new replica will be created.</p>
+     */
+    inline CreateReplicationGroupMemberAction& WithRegionName(const char* value) { SetRegionName(value); return *this;}
+
+
+    /**
+     * <p>The AWS KMS customer master key (CMK) that should be used for AWS KMS
+     * encryption in the new replica. To specify a CMK, use its key ID, Amazon Resource
+     * Name (ARN), alias name, or alias ARN. Note that you should only provide this
+     * parameter if the key is different from the default DynamoDB KMS master key
+     * alias/aws/dynamodb.</p>
+     */
+    inline const Aws::String& GetKMSMasterKeyId() const{ return m_kMSMasterKeyId; }
+
+    /**
+     * <p>The AWS KMS customer master key (CMK) that should be used for AWS KMS
+     * encryption in the new replica. To specify a CMK, use its key ID, Amazon Resource
+     * Name (ARN), alias name, or alias ARN. Note that you should only provide this
+     * parameter if the key is different from the default DynamoDB KMS master key
+     * alias/aws/dynamodb.</p>
+     */
+    inline bool KMSMasterKeyIdHasBeenSet() const { return m_kMSMasterKeyIdHasBeenSet; }
+
+    /**
+     * <p>The AWS KMS customer master key (CMK) that should be used for AWS KMS
+     * encryption in the new replica. To specify a CMK, use its key ID, Amazon Resource
+     * Name (ARN), alias name, or alias ARN. Note that you should only provide this
+     * parameter if the key is different from the default DynamoDB KMS master key
+     * alias/aws/dynamodb.</p>
+     */
+    inline void SetKMSMasterKeyId(const Aws::String& value) { m_kMSMasterKeyIdHasBeenSet = true; m_kMSMasterKeyId = value; }
+
+    /**
+     * <p>The AWS KMS customer master key (CMK) that should be used for AWS KMS
+     * encryption in the new replica. To specify a CMK, use its key ID, Amazon Resource
+     * Name (ARN), alias name, or alias ARN. Note that you should only provide this
+     * parameter if the key is different from the default DynamoDB KMS master key
+     * alias/aws/dynamodb.</p>
+     */
+    inline void SetKMSMasterKeyId(Aws::String&& value) { m_kMSMasterKeyIdHasBeenSet = true; m_kMSMasterKeyId = std::move(value); }
+
+    /**
+     * <p>The AWS KMS customer master key (CMK) that should be used for AWS KMS
+     * encryption in the new replica. To specify a CMK, use its key ID, Amazon Resource
+     * Name (ARN), alias name, or alias ARN. Note that you should only provide this
+     * parameter if the key is different from the default DynamoDB KMS master key
+     * alias/aws/dynamodb.</p>
+     */
+    inline void SetKMSMasterKeyId(const char* value) { m_kMSMasterKeyIdHasBeenSet = true; m_kMSMasterKeyId.assign(value); }
+
+    /**
+     * <p>The AWS KMS customer master key (CMK) that should be used for AWS KMS
+     * encryption in the new replica. To specify a CMK, use its key ID, Amazon Resource
+     * Name (ARN), alias name, or alias ARN. Note that you should only provide this
+     * parameter if the key is different from the default DynamoDB KMS master key
+     * alias/aws/dynamodb.</p>
+     */
+    inline CreateReplicationGroupMemberAction& WithKMSMasterKeyId(const Aws::String& value) { SetKMSMasterKeyId(value); return *this;}
+
+    /**
+     * <p>The AWS KMS customer master key (CMK) that should be used for AWS KMS
+     * encryption in the new replica. To specify a CMK, use its key ID, Amazon Resource
+     * Name (ARN), alias name, or alias ARN. Note that you should only provide this
+     * parameter if the key is different from the default DynamoDB KMS master key
+     * alias/aws/dynamodb.</p>
+     */
+    inline CreateReplicationGroupMemberAction& WithKMSMasterKeyId(Aws::String&& value) { SetKMSMasterKeyId(std::move(value)); return *this;}
+
+    /**
+     * <p>The AWS KMS customer master key (CMK) that should be used for AWS KMS
+     * encryption in the new replica. To specify a CMK, use its key ID, Amazon Resource
+     * Name (ARN), alias name, or alias ARN. Note that you should only provide this
+     * parameter if the key is different from the default DynamoDB KMS master key
+     * alias/aws/dynamodb.</p>
+     */
+    inline CreateReplicationGroupMemberAction& WithKMSMasterKeyId(const char* value) { SetKMSMasterKeyId(value); return *this;}
+
+
+    /**
+     * <p>Replica-specific provisioned throughput. If not specified, uses the source
+     * table's provisioned throughput settings.</p>
+     */
+    inline const ProvisionedThroughputOverride& GetProvisionedThroughputOverride() const{ return m_provisionedThroughputOverride; }
+
+    /**
+     * <p>Replica-specific provisioned throughput. If not specified, uses the source
+     * table's provisioned throughput settings.</p>
+     */
+    inline bool ProvisionedThroughputOverrideHasBeenSet() const { return m_provisionedThroughputOverrideHasBeenSet; }
+
+    /**
+     * <p>Replica-specific provisioned throughput. If not specified, uses the source
+     * table's provisioned throughput settings.</p>
+     */
+    inline void SetProvisionedThroughputOverride(const ProvisionedThroughputOverride& value) { m_provisionedThroughputOverrideHasBeenSet = true; m_provisionedThroughputOverride = value; }
+
+    /**
+     * <p>Replica-specific provisioned throughput. If not specified, uses the source
+     * table's provisioned throughput settings.</p>
+     */
+    inline void SetProvisionedThroughputOverride(ProvisionedThroughputOverride&& value) { m_provisionedThroughputOverrideHasBeenSet = true; m_provisionedThroughputOverride = std::move(value); }
+
+    /**
+     * <p>Replica-specific provisioned throughput. If not specified, uses the source
+     * table's provisioned throughput settings.</p>
+     */
+    inline CreateReplicationGroupMemberAction& WithProvisionedThroughputOverride(const ProvisionedThroughputOverride& value) { SetProvisionedThroughputOverride(value); return *this;}
+
+    /**
+     * <p>Replica-specific provisioned throughput. If not specified, uses the source
+     * table's provisioned throughput settings.</p>
+     */
+    inline CreateReplicationGroupMemberAction& WithProvisionedThroughputOverride(ProvisionedThroughputOverride&& value) { SetProvisionedThroughputOverride(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Replica-specific global secondary index settings.</p>
+     */
+    inline const Aws::Vector<ReplicaGlobalSecondaryIndex>& GetGlobalSecondaryIndexes() const{ return m_globalSecondaryIndexes; }
+
+    /**
+     * <p>Replica-specific global secondary index settings.</p>
+     */
+    inline bool GlobalSecondaryIndexesHasBeenSet() const { return m_globalSecondaryIndexesHasBeenSet; }
+
+    /**
+     * <p>Replica-specific global secondary index settings.</p>
+     */
+    inline void SetGlobalSecondaryIndexes(const Aws::Vector<ReplicaGlobalSecondaryIndex>& value) { m_globalSecondaryIndexesHasBeenSet = true; m_globalSecondaryIndexes = value; }
+
+    /**
+     * <p>Replica-specific global secondary index settings.</p>
+     */
+    inline void SetGlobalSecondaryIndexes(Aws::Vector<ReplicaGlobalSecondaryIndex>&& value) { m_globalSecondaryIndexesHasBeenSet = true; m_globalSecondaryIndexes = std::move(value); }
+
+    /**
+     * <p>Replica-specific global secondary index settings.</p>
+     */
+    inline CreateReplicationGroupMemberAction& WithGlobalSecondaryIndexes(const Aws::Vector<ReplicaGlobalSecondaryIndex>& value) { SetGlobalSecondaryIndexes(value); return *this;}
+
+    /**
+     * <p>Replica-specific global secondary index settings.</p>
+     */
+    inline CreateReplicationGroupMemberAction& WithGlobalSecondaryIndexes(Aws::Vector<ReplicaGlobalSecondaryIndex>&& value) { SetGlobalSecondaryIndexes(std::move(value)); return *this;}
+
+    /**
+     * <p>Replica-specific global secondary index settings.</p>
+     */
+    inline CreateReplicationGroupMemberAction& AddGlobalSecondaryIndexes(const ReplicaGlobalSecondaryIndex& value) { m_globalSecondaryIndexesHasBeenSet = true; m_globalSecondaryIndexes.push_back(value); return *this; }
+
+    /**
+     * <p>Replica-specific global secondary index settings.</p>
+     */
+    inline CreateReplicationGroupMemberAction& AddGlobalSecondaryIndexes(ReplicaGlobalSecondaryIndex&& value) { m_globalSecondaryIndexesHasBeenSet = true; m_globalSecondaryIndexes.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_regionName;
+    bool m_regionNameHasBeenSet;
+
+    Aws::String m_kMSMasterKeyId;
+    bool m_kMSMasterKeyIdHasBeenSet;
+
+    ProvisionedThroughputOverride m_provisionedThroughputOverride;
+    bool m_provisionedThroughputOverrideHasBeenSet;
+
+    Aws::Vector<ReplicaGlobalSecondaryIndex> m_globalSecondaryIndexes;
+    bool m_globalSecondaryIndexesHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/CreateTableResult.h

@@ -0,0 +1,73 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/model/TableDescription.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+  /**
+   * <p>Represents the output of a <code>CreateTable</code> operation.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/CreateTableOutput">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API CreateTableResult
+  {
+  public:
+    CreateTableResult();
+    CreateTableResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    CreateTableResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Represents the properties of the table.</p>
+     */
+    inline const TableDescription& GetTableDescription() const{ return m_tableDescription; }
+
+    /**
+     * <p>Represents the properties of the table.</p>
+     */
+    inline void SetTableDescription(const TableDescription& value) { m_tableDescription = value; }
+
+    /**
+     * <p>Represents the properties of the table.</p>
+     */
+    inline void SetTableDescription(TableDescription&& value) { m_tableDescription = std::move(value); }
+
+    /**
+     * <p>Represents the properties of the table.</p>
+     */
+    inline CreateTableResult& WithTableDescription(const TableDescription& value) { SetTableDescription(value); return *this;}
+
+    /**
+     * <p>Represents the properties of the table.</p>
+     */
+    inline CreateTableResult& WithTableDescription(TableDescription&& value) { SetTableDescription(std::move(value)); return *this;}
+
+  private:
+
+    TableDescription m_tableDescription;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/Delete.h

@@ -0,0 +1,405 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/dynamodb/model/ReturnValuesOnConditionCheckFailure.h>
+#include <aws/dynamodb/model/AttributeValue.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents a request to perform a <code>DeleteItem</code>
+   * operation.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/Delete">AWS API
+   * Reference</a></p>
+   */
+  class AWS_DYNAMODB_API Delete
+  {
+  public:
+    Delete();
+    Delete(Aws::Utils::Json::JsonView jsonValue);
+    Delete& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The primary key of the item to be deleted. Each element consists of an
+     * attribute name and a value for that attribute.</p>
+     */
+    inline const Aws::Map<Aws::String, AttributeValue>& GetKey() const{ return m_key; }
+
+    /**
+     * <p>The primary key of the item to be deleted. Each element consists of an
+     * attribute name and a value for that attribute.</p>
+     */
+    inline bool KeyHasBeenSet() const { return m_keyHasBeenSet; }
+
+    /**
+     * <p>The primary key of the item to be deleted. Each element consists of an
+     * attribute name and a value for that attribute.</p>
+     */
+    inline void SetKey(const Aws::Map<Aws::String, AttributeValue>& value) { m_keyHasBeenSet = true; m_key = value; }
+
+    /**
+     * <p>The primary key of the item to be deleted. Each element consists of an
+     * attribute name and a value for that attribute.</p>
+     */
+    inline void SetKey(Aws::Map<Aws::String, AttributeValue>&& value) { m_keyHasBeenSet = true; m_key = std::move(value); }
+
+    /**
+     * <p>The primary key of the item to be deleted. Each element consists of an
+     * attribute name and a value for that attribute.</p>
+     */
+    inline Delete& WithKey(const Aws::Map<Aws::String, AttributeValue>& value) { SetKey(value); return *this;}
+
+    /**
+     * <p>The primary key of the item to be deleted. Each element consists of an
+     * attribute name and a value for that attribute.</p>
+     */
+    inline Delete& WithKey(Aws::Map<Aws::String, AttributeValue>&& value) { SetKey(std::move(value)); return *this;}
+
+    /**
+     * <p>The primary key of the item to be deleted. Each element consists of an
+     * attribute name and a value for that attribute.</p>
+     */
+    inline Delete& AddKey(const Aws::String& key, const AttributeValue& value) { m_keyHasBeenSet = true; m_key.emplace(key, value); return *this; }
+
+    /**
+     * <p>The primary key of the item to be deleted. Each element consists of an
+     * attribute name and a value for that attribute.</p>
+     */
+    inline Delete& AddKey(Aws::String&& key, const AttributeValue& value) { m_keyHasBeenSet = true; m_key.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>The primary key of the item to be deleted. Each element consists of an
+     * attribute name and a value for that attribute.</p>
+     */
+    inline Delete& AddKey(const Aws::String& key, AttributeValue&& value) { m_keyHasBeenSet = true; m_key.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>The primary key of the item to be deleted. Each element consists of an
+     * attribute name and a value for that attribute.</p>
+     */
+    inline Delete& AddKey(Aws::String&& key, AttributeValue&& value) { m_keyHasBeenSet = true; m_key.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>The primary key of the item to be deleted. Each element consists of an
+     * attribute name and a value for that attribute.</p>
+     */
+    inline Delete& AddKey(const char* key, AttributeValue&& value) { m_keyHasBeenSet = true; m_key.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>The primary key of the item to be deleted. Each element consists of an
+     * attribute name and a value for that attribute.</p>
+     */
+    inline Delete& AddKey(const char* key, const AttributeValue& value) { m_keyHasBeenSet = true; m_key.emplace(key, value); return *this; }
+
+
+    /**
+     * <p>Name of the table in which the item to be deleted resides.</p>
+     */
+    inline const Aws::String& GetTableName() const{ return m_tableName; }
+
+    /**
+     * <p>Name of the table in which the item to be deleted resides.</p>
+     */
+    inline bool TableNameHasBeenSet() const { return m_tableNameHasBeenSet; }
+
+    /**
+     * <p>Name of the table in which the item to be deleted resides.</p>
+     */
+    inline void SetTableName(const Aws::String& value) { m_tableNameHasBeenSet = true; m_tableName = value; }
+
+    /**
+     * <p>Name of the table in which the item to be deleted resides.</p>
+     */
+    inline void SetTableName(Aws::String&& value) { m_tableNameHasBeenSet = true; m_tableName = std::move(value); }
+
+    /**
+     * <p>Name of the table in which the item to be deleted resides.</p>
+     */
+    inline void SetTableName(const char* value) { m_tableNameHasBeenSet = true; m_tableName.assign(value); }
+
+    /**
+     * <p>Name of the table in which the item to be deleted resides.</p>
+     */
+    inline Delete& WithTableName(const Aws::String& value) { SetTableName(value); return *this;}
+
+    /**
+     * <p>Name of the table in which the item to be deleted resides.</p>
+     */
+    inline Delete& WithTableName(Aws::String&& value) { SetTableName(std::move(value)); return *this;}
+
+    /**
+     * <p>Name of the table in which the item to be deleted resides.</p>
+     */
+    inline Delete& WithTableName(const char* value) { SetTableName(value); return *this;}
+
+
+    /**
+     * <p>A condition that must be satisfied in order for a conditional delete to
+     * succeed.</p>
+     */
+    inline const Aws::String& GetConditionExpression() const{ return m_conditionExpression; }
+
+    /**
+     * <p>A condition that must be satisfied in order for a conditional delete to
+     * succeed.</p>
+     */
+    inline bool ConditionExpressionHasBeenSet() const { return m_conditionExpressionHasBeenSet; }
+
+    /**
+     * <p>A condition that must be satisfied in order for a conditional delete to
+     * succeed.</p>
+     */
+    inline void SetConditionExpression(const Aws::String& value) { m_conditionExpressionHasBeenSet = true; m_conditionExpression = value; }
+
+    /**
+     * <p>A condition that must be satisfied in order for a conditional delete to
+     * succeed.</p>
+     */
+    inline void SetConditionExpression(Aws::String&& value) { m_conditionExpressionHasBeenSet = true; m_conditionExpression = std::move(value); }
+
+    /**
+     * <p>A condition that must be satisfied in order for a conditional delete to
+     * succeed.</p>
+     */
+    inline void SetConditionExpression(const char* value) { m_conditionExpressionHasBeenSet = true; m_conditionExpression.assign(value); }
+
+    /**
+     * <p>A condition that must be satisfied in order for a conditional delete to
+     * succeed.</p>
+     */
+    inline Delete& WithConditionExpression(const Aws::String& value) { SetConditionExpression(value); return *this;}
+
+    /**
+     * <p>A condition that must be satisfied in order for a conditional delete to
+     * succeed.</p>
+     */
+    inline Delete& WithConditionExpression(Aws::String&& value) { SetConditionExpression(std::move(value)); return *this;}
+
+    /**
+     * <p>A condition that must be satisfied in order for a conditional delete to
+     * succeed.</p>
+     */
+    inline Delete& WithConditionExpression(const char* value) { SetConditionExpression(value); return *this;}
+
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression.</p>
+     */
+    inline const Aws::Map<Aws::String, Aws::String>& GetExpressionAttributeNames() const{ return m_expressionAttributeNames; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression.</p>
+     */
+    inline bool ExpressionAttributeNamesHasBeenSet() const { return m_expressionAttributeNamesHasBeenSet; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression.</p>
+     */
+    inline void SetExpressionAttributeNames(const Aws::Map<Aws::String, Aws::String>& value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames = value; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression.</p>
+     */
+    inline void SetExpressionAttributeNames(Aws::Map<Aws::String, Aws::String>&& value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames = std::move(value); }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression.</p>
+     */
+    inline Delete& WithExpressionAttributeNames(const Aws::Map<Aws::String, Aws::String>& value) { SetExpressionAttributeNames(value); return *this;}
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression.</p>
+     */
+    inline Delete& WithExpressionAttributeNames(Aws::Map<Aws::String, Aws::String>&& value) { SetExpressionAttributeNames(std::move(value)); return *this;}
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression.</p>
+     */
+    inline Delete& AddExpressionAttributeNames(const Aws::String& key, const Aws::String& value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames.emplace(key, value); return *this; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression.</p>
+     */
+    inline Delete& AddExpressionAttributeNames(Aws::String&& key, const Aws::String& value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression.</p>
+     */
+    inline Delete& AddExpressionAttributeNames(const Aws::String& key, Aws::String&& value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression.</p>
+     */
+    inline Delete& AddExpressionAttributeNames(Aws::String&& key, Aws::String&& value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression.</p>
+     */
+    inline Delete& AddExpressionAttributeNames(const char* key, Aws::String&& value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression.</p>
+     */
+    inline Delete& AddExpressionAttributeNames(Aws::String&& key, const char* value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression.</p>
+     */
+    inline Delete& AddExpressionAttributeNames(const char* key, const char* value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames.emplace(key, value); return *this; }
+
+
+    /**
+     * <p>One or more values that can be substituted in an expression.</p>
+     */
+    inline const Aws::Map<Aws::String, AttributeValue>& GetExpressionAttributeValues() const{ return m_expressionAttributeValues; }
+
+    /**
+     * <p>One or more values that can be substituted in an expression.</p>
+     */
+    inline bool ExpressionAttributeValuesHasBeenSet() const { return m_expressionAttributeValuesHasBeenSet; }
+
+    /**
+     * <p>One or more values that can be substituted in an expression.</p>
+     */
+    inline void SetExpressionAttributeValues(const Aws::Map<Aws::String, AttributeValue>& value) { m_expressionAttributeValuesHasBeenSet = true; m_expressionAttributeValues = value; }
+
+    /**
+     * <p>One or more values that can be substituted in an expression.</p>
+     */
+    inline void SetExpressionAttributeValues(Aws::Map<Aws::String, AttributeValue>&& value) { m_expressionAttributeValuesHasBeenSet = true; m_expressionAttributeValues = std::move(value); }
+
+    /**
+     * <p>One or more values that can be substituted in an expression.</p>
+     */
+    inline Delete& WithExpressionAttributeValues(const Aws::Map<Aws::String, AttributeValue>& value) { SetExpressionAttributeValues(value); return *this;}
+
+    /**
+     * <p>One or more values that can be substituted in an expression.</p>
+     */
+    inline Delete& WithExpressionAttributeValues(Aws::Map<Aws::String, AttributeValue>&& value) { SetExpressionAttributeValues(std::move(value)); return *this;}
+
+    /**
+     * <p>One or more values that can be substituted in an expression.</p>
+     */
+    inline Delete& AddExpressionAttributeValues(const Aws::String& key, const AttributeValue& value) { m_expressionAttributeValuesHasBeenSet = true; m_expressionAttributeValues.emplace(key, value); return *this; }
+
+    /**
+     * <p>One or more values that can be substituted in an expression.</p>
+     */
+    inline Delete& AddExpressionAttributeValues(Aws::String&& key, const AttributeValue& value) { m_expressionAttributeValuesHasBeenSet = true; m_expressionAttributeValues.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>One or more values that can be substituted in an expression.</p>
+     */
+    inline Delete& AddExpressionAttributeValues(const Aws::String& key, AttributeValue&& value) { m_expressionAttributeValuesHasBeenSet = true; m_expressionAttributeValues.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>One or more values that can be substituted in an expression.</p>
+     */
+    inline Delete& AddExpressionAttributeValues(Aws::String&& key, AttributeValue&& value) { m_expressionAttributeValuesHasBeenSet = true; m_expressionAttributeValues.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>One or more values that can be substituted in an expression.</p>
+     */
+    inline Delete& AddExpressionAttributeValues(const char* key, AttributeValue&& value) { m_expressionAttributeValuesHasBeenSet = true; m_expressionAttributeValues.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>One or more values that can be substituted in an expression.</p>
+     */
+    inline Delete& AddExpressionAttributeValues(const char* key, const AttributeValue& value) { m_expressionAttributeValuesHasBeenSet = true; m_expressionAttributeValues.emplace(key, value); return *this; }
+
+
+    /**
+     * <p>Use <code>ReturnValuesOnConditionCheckFailure</code> to get the item
+     * attributes if the <code>Delete</code> condition fails. For
+     * <code>ReturnValuesOnConditionCheckFailure</code>, the valid values are: NONE and
+     * ALL_OLD.</p>
+     */
+    inline const ReturnValuesOnConditionCheckFailure& GetReturnValuesOnConditionCheckFailure() const{ return m_returnValuesOnConditionCheckFailure; }
+
+    /**
+     * <p>Use <code>ReturnValuesOnConditionCheckFailure</code> to get the item
+     * attributes if the <code>Delete</code> condition fails. For
+     * <code>ReturnValuesOnConditionCheckFailure</code>, the valid values are: NONE and
+     * ALL_OLD.</p>
+     */
+    inline bool ReturnValuesOnConditionCheckFailureHasBeenSet() const { return m_returnValuesOnConditionCheckFailureHasBeenSet; }
+
+    /**
+     * <p>Use <code>ReturnValuesOnConditionCheckFailure</code> to get the item
+     * attributes if the <code>Delete</code> condition fails. For
+     * <code>ReturnValuesOnConditionCheckFailure</code>, the valid values are: NONE and
+     * ALL_OLD.</p>
+     */
+    inline void SetReturnValuesOnConditionCheckFailure(const ReturnValuesOnConditionCheckFailure& value) { m_returnValuesOnConditionCheckFailureHasBeenSet = true; m_returnValuesOnConditionCheckFailure = value; }
+
+    /**
+     * <p>Use <code>ReturnValuesOnConditionCheckFailure</code> to get the item
+     * attributes if the <code>Delete</code> condition fails. For
+     * <code>ReturnValuesOnConditionCheckFailure</code>, the valid values are: NONE and
+     * ALL_OLD.</p>
+     */
+    inline void SetReturnValuesOnConditionCheckFailure(ReturnValuesOnConditionCheckFailure&& value) { m_returnValuesOnConditionCheckFailureHasBeenSet = true; m_returnValuesOnConditionCheckFailure = std::move(value); }
+
+    /**
+     * <p>Use <code>ReturnValuesOnConditionCheckFailure</code> to get the item
+     * attributes if the <code>Delete</code> condition fails. For
+     * <code>ReturnValuesOnConditionCheckFailure</code>, the valid values are: NONE and
+     * ALL_OLD.</p>
+     */
+    inline Delete& WithReturnValuesOnConditionCheckFailure(const ReturnValuesOnConditionCheckFailure& value) { SetReturnValuesOnConditionCheckFailure(value); return *this;}
+
+    /**
+     * <p>Use <code>ReturnValuesOnConditionCheckFailure</code> to get the item
+     * attributes if the <code>Delete</code> condition fails. For
+     * <code>ReturnValuesOnConditionCheckFailure</code>, the valid values are: NONE and
+     * ALL_OLD.</p>
+     */
+    inline Delete& WithReturnValuesOnConditionCheckFailure(ReturnValuesOnConditionCheckFailure&& value) { SetReturnValuesOnConditionCheckFailure(std::move(value)); return *this;}
+
+  private:
+
+    Aws::Map<Aws::String, AttributeValue> m_key;
+    bool m_keyHasBeenSet;
+
+    Aws::String m_tableName;
+    bool m_tableNameHasBeenSet;
+
+    Aws::String m_conditionExpression;
+    bool m_conditionExpressionHasBeenSet;
+
+    Aws::Map<Aws::String, Aws::String> m_expressionAttributeNames;
+    bool m_expressionAttributeNamesHasBeenSet;
+
+    Aws::Map<Aws::String, AttributeValue> m_expressionAttributeValues;
+    bool m_expressionAttributeValuesHasBeenSet;
+
+    ReturnValuesOnConditionCheckFailure m_returnValuesOnConditionCheckFailure;
+    bool m_returnValuesOnConditionCheckFailureHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DeleteBackupRequest.h

@@ -0,0 +1,85 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/DynamoDBRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DYNAMODB_API DeleteBackupRequest : public DynamoDBRequest
+  {
+  public:
+    DeleteBackupRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DeleteBackup"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The ARN associated with the backup.</p>
+     */
+    inline const Aws::String& GetBackupArn() const{ return m_backupArn; }
+
+    /**
+     * <p>The ARN associated with the backup.</p>
+     */
+    inline bool BackupArnHasBeenSet() const { return m_backupArnHasBeenSet; }
+
+    /**
+     * <p>The ARN associated with the backup.</p>
+     */
+    inline void SetBackupArn(const Aws::String& value) { m_backupArnHasBeenSet = true; m_backupArn = value; }
+
+    /**
+     * <p>The ARN associated with the backup.</p>
+     */
+    inline void SetBackupArn(Aws::String&& value) { m_backupArnHasBeenSet = true; m_backupArn = std::move(value); }
+
+    /**
+     * <p>The ARN associated with the backup.</p>
+     */
+    inline void SetBackupArn(const char* value) { m_backupArnHasBeenSet = true; m_backupArn.assign(value); }
+
+    /**
+     * <p>The ARN associated with the backup.</p>
+     */
+    inline DeleteBackupRequest& WithBackupArn(const Aws::String& value) { SetBackupArn(value); return *this;}
+
+    /**
+     * <p>The ARN associated with the backup.</p>
+     */
+    inline DeleteBackupRequest& WithBackupArn(Aws::String&& value) { SetBackupArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The ARN associated with the backup.</p>
+     */
+    inline DeleteBackupRequest& WithBackupArn(const char* value) { SetBackupArn(value); return *this;}
+
+  private:
+
+    Aws::String m_backupArn;
+    bool m_backupArnHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DeleteBackupResult.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/model/BackupDescription.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+  class AWS_DYNAMODB_API DeleteBackupResult
+  {
+  public:
+    DeleteBackupResult();
+    DeleteBackupResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DeleteBackupResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Contains the description of the backup created for the table.</p>
+     */
+    inline const BackupDescription& GetBackupDescription() const{ return m_backupDescription; }
+
+    /**
+     * <p>Contains the description of the backup created for the table.</p>
+     */
+    inline void SetBackupDescription(const BackupDescription& value) { m_backupDescription = value; }
+
+    /**
+     * <p>Contains the description of the backup created for the table.</p>
+     */
+    inline void SetBackupDescription(BackupDescription&& value) { m_backupDescription = std::move(value); }
+
+    /**
+     * <p>Contains the description of the backup created for the table.</p>
+     */
+    inline DeleteBackupResult& WithBackupDescription(const BackupDescription& value) { SetBackupDescription(value); return *this;}
+
+    /**
+     * <p>Contains the description of the backup created for the table.</p>
+     */
+    inline DeleteBackupResult& WithBackupDescription(BackupDescription&& value) { SetBackupDescription(std::move(value)); return *this;}
+
+  private:
+
+    BackupDescription m_backupDescription;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DeleteGlobalSecondaryIndexAction.h

@@ -0,0 +1,89 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents a global secondary index to be deleted from an existing
+   * table.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DeleteGlobalSecondaryIndexAction">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API DeleteGlobalSecondaryIndexAction
+  {
+  public:
+    DeleteGlobalSecondaryIndexAction();
+    DeleteGlobalSecondaryIndexAction(Aws::Utils::Json::JsonView jsonValue);
+    DeleteGlobalSecondaryIndexAction& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The name of the global secondary index to be deleted.</p>
+     */
+    inline const Aws::String& GetIndexName() const{ return m_indexName; }
+
+    /**
+     * <p>The name of the global secondary index to be deleted.</p>
+     */
+    inline bool IndexNameHasBeenSet() const { return m_indexNameHasBeenSet; }
+
+    /**
+     * <p>The name of the global secondary index to be deleted.</p>
+     */
+    inline void SetIndexName(const Aws::String& value) { m_indexNameHasBeenSet = true; m_indexName = value; }
+
+    /**
+     * <p>The name of the global secondary index to be deleted.</p>
+     */
+    inline void SetIndexName(Aws::String&& value) { m_indexNameHasBeenSet = true; m_indexName = std::move(value); }
+
+    /**
+     * <p>The name of the global secondary index to be deleted.</p>
+     */
+    inline void SetIndexName(const char* value) { m_indexNameHasBeenSet = true; m_indexName.assign(value); }
+
+    /**
+     * <p>The name of the global secondary index to be deleted.</p>
+     */
+    inline DeleteGlobalSecondaryIndexAction& WithIndexName(const Aws::String& value) { SetIndexName(value); return *this;}
+
+    /**
+     * <p>The name of the global secondary index to be deleted.</p>
+     */
+    inline DeleteGlobalSecondaryIndexAction& WithIndexName(Aws::String&& value) { SetIndexName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the global secondary index to be deleted.</p>
+     */
+    inline DeleteGlobalSecondaryIndexAction& WithIndexName(const char* value) { SetIndexName(value); return *this;}
+
+  private:
+
+    Aws::String m_indexName;
+    bool m_indexNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DeleteItemResult.h

@@ -0,0 +1,306 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <aws/dynamodb/model/ConsumedCapacity.h>
+#include <aws/dynamodb/model/ItemCollectionMetrics.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/dynamodb/model/AttributeValue.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+  /**
+   * <p>Represents the output of a <code>DeleteItem</code> operation.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DeleteItemOutput">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API DeleteItemResult
+  {
+  public:
+    DeleteItemResult();
+    DeleteItemResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DeleteItemResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, representing
+     * the item as it appeared before the <code>DeleteItem</code> operation. This map
+     * appears in the response only if <code>ReturnValues</code> was specified as
+     * <code>ALL_OLD</code> in the request.</p>
+     */
+    inline const Aws::Map<Aws::String, AttributeValue>& GetAttributes() const{ return m_attributes; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, representing
+     * the item as it appeared before the <code>DeleteItem</code> operation. This map
+     * appears in the response only if <code>ReturnValues</code> was specified as
+     * <code>ALL_OLD</code> in the request.</p>
+     */
+    inline void SetAttributes(const Aws::Map<Aws::String, AttributeValue>& value) { m_attributes = value; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, representing
+     * the item as it appeared before the <code>DeleteItem</code> operation. This map
+     * appears in the response only if <code>ReturnValues</code> was specified as
+     * <code>ALL_OLD</code> in the request.</p>
+     */
+    inline void SetAttributes(Aws::Map<Aws::String, AttributeValue>&& value) { m_attributes = std::move(value); }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, representing
+     * the item as it appeared before the <code>DeleteItem</code> operation. This map
+     * appears in the response only if <code>ReturnValues</code> was specified as
+     * <code>ALL_OLD</code> in the request.</p>
+     */
+    inline DeleteItemResult& WithAttributes(const Aws::Map<Aws::String, AttributeValue>& value) { SetAttributes(value); return *this;}
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, representing
+     * the item as it appeared before the <code>DeleteItem</code> operation. This map
+     * appears in the response only if <code>ReturnValues</code> was specified as
+     * <code>ALL_OLD</code> in the request.</p>
+     */
+    inline DeleteItemResult& WithAttributes(Aws::Map<Aws::String, AttributeValue>&& value) { SetAttributes(std::move(value)); return *this;}
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, representing
+     * the item as it appeared before the <code>DeleteItem</code> operation. This map
+     * appears in the response only if <code>ReturnValues</code> was specified as
+     * <code>ALL_OLD</code> in the request.</p>
+     */
+    inline DeleteItemResult& AddAttributes(const Aws::String& key, const AttributeValue& value) { m_attributes.emplace(key, value); return *this; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, representing
+     * the item as it appeared before the <code>DeleteItem</code> operation. This map
+     * appears in the response only if <code>ReturnValues</code> was specified as
+     * <code>ALL_OLD</code> in the request.</p>
+     */
+    inline DeleteItemResult& AddAttributes(Aws::String&& key, const AttributeValue& value) { m_attributes.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, representing
+     * the item as it appeared before the <code>DeleteItem</code> operation. This map
+     * appears in the response only if <code>ReturnValues</code> was specified as
+     * <code>ALL_OLD</code> in the request.</p>
+     */
+    inline DeleteItemResult& AddAttributes(const Aws::String& key, AttributeValue&& value) { m_attributes.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, representing
+     * the item as it appeared before the <code>DeleteItem</code> operation. This map
+     * appears in the response only if <code>ReturnValues</code> was specified as
+     * <code>ALL_OLD</code> in the request.</p>
+     */
+    inline DeleteItemResult& AddAttributes(Aws::String&& key, AttributeValue&& value) { m_attributes.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, representing
+     * the item as it appeared before the <code>DeleteItem</code> operation. This map
+     * appears in the response only if <code>ReturnValues</code> was specified as
+     * <code>ALL_OLD</code> in the request.</p>
+     */
+    inline DeleteItemResult& AddAttributes(const char* key, AttributeValue&& value) { m_attributes.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, representing
+     * the item as it appeared before the <code>DeleteItem</code> operation. This map
+     * appears in the response only if <code>ReturnValues</code> was specified as
+     * <code>ALL_OLD</code> in the request.</p>
+     */
+    inline DeleteItemResult& AddAttributes(const char* key, const AttributeValue& value) { m_attributes.emplace(key, value); return *this; }
+
+
+    /**
+     * <p>The capacity units consumed by the <code>DeleteItem</code> operation. The
+     * data returned includes the total provisioned throughput consumed, along with
+     * statistics for the table and any indexes involved in the operation.
+     * <code>ConsumedCapacity</code> is only returned if the
+     * <code>ReturnConsumedCapacity</code> parameter was specified. For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ProvisionedThroughputIntro.html">Provisioned
+     * Mode</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline const ConsumedCapacity& GetConsumedCapacity() const{ return m_consumedCapacity; }
+
+    /**
+     * <p>The capacity units consumed by the <code>DeleteItem</code> operation. The
+     * data returned includes the total provisioned throughput consumed, along with
+     * statistics for the table and any indexes involved in the operation.
+     * <code>ConsumedCapacity</code> is only returned if the
+     * <code>ReturnConsumedCapacity</code> parameter was specified. For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ProvisionedThroughputIntro.html">Provisioned
+     * Mode</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline void SetConsumedCapacity(const ConsumedCapacity& value) { m_consumedCapacity = value; }
+
+    /**
+     * <p>The capacity units consumed by the <code>DeleteItem</code> operation. The
+     * data returned includes the total provisioned throughput consumed, along with
+     * statistics for the table and any indexes involved in the operation.
+     * <code>ConsumedCapacity</code> is only returned if the
+     * <code>ReturnConsumedCapacity</code> parameter was specified. For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ProvisionedThroughputIntro.html">Provisioned
+     * Mode</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline void SetConsumedCapacity(ConsumedCapacity&& value) { m_consumedCapacity = std::move(value); }
+
+    /**
+     * <p>The capacity units consumed by the <code>DeleteItem</code> operation. The
+     * data returned includes the total provisioned throughput consumed, along with
+     * statistics for the table and any indexes involved in the operation.
+     * <code>ConsumedCapacity</code> is only returned if the
+     * <code>ReturnConsumedCapacity</code> parameter was specified. For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ProvisionedThroughputIntro.html">Provisioned
+     * Mode</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline DeleteItemResult& WithConsumedCapacity(const ConsumedCapacity& value) { SetConsumedCapacity(value); return *this;}
+
+    /**
+     * <p>The capacity units consumed by the <code>DeleteItem</code> operation. The
+     * data returned includes the total provisioned throughput consumed, along with
+     * statistics for the table and any indexes involved in the operation.
+     * <code>ConsumedCapacity</code> is only returned if the
+     * <code>ReturnConsumedCapacity</code> parameter was specified. For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ProvisionedThroughputIntro.html">Provisioned
+     * Mode</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline DeleteItemResult& WithConsumedCapacity(ConsumedCapacity&& value) { SetConsumedCapacity(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Information about item collections, if any, that were affected by the
+     * <code>DeleteItem</code> operation. <code>ItemCollectionMetrics</code> is only
+     * returned if the <code>ReturnItemCollectionMetrics</code> parameter was
+     * specified. If the table does not have any local secondary indexes, this
+     * information is not returned in the response.</p> <p>Each
+     * <code>ItemCollectionMetrics</code> element consists of:</p> <ul> <li> <p>
+     * <code>ItemCollectionKey</code> - The partition key value of the item collection.
+     * This is the same as the partition key value of the item itself.</p> </li> <li>
+     * <p> <code>SizeEstimateRangeGB</code> - An estimate of item collection size, in
+     * gigabytes. This value is a two-element array containing a lower bound and an
+     * upper bound for the estimate. The estimate includes the size of all the items in
+     * the table, plus the size of all attributes projected into all of the local
+     * secondary indexes on that table. Use this estimate to measure whether a local
+     * secondary index is approaching its size limit.</p> <p>The estimate is subject to
+     * change over time; therefore, do not rely on the precision or accuracy of the
+     * estimate.</p> </li> </ul>
+     */
+    inline const ItemCollectionMetrics& GetItemCollectionMetrics() const{ return m_itemCollectionMetrics; }
+
+    /**
+     * <p>Information about item collections, if any, that were affected by the
+     * <code>DeleteItem</code> operation. <code>ItemCollectionMetrics</code> is only
+     * returned if the <code>ReturnItemCollectionMetrics</code> parameter was
+     * specified. If the table does not have any local secondary indexes, this
+     * information is not returned in the response.</p> <p>Each
+     * <code>ItemCollectionMetrics</code> element consists of:</p> <ul> <li> <p>
+     * <code>ItemCollectionKey</code> - The partition key value of the item collection.
+     * This is the same as the partition key value of the item itself.</p> </li> <li>
+     * <p> <code>SizeEstimateRangeGB</code> - An estimate of item collection size, in
+     * gigabytes. This value is a two-element array containing a lower bound and an
+     * upper bound for the estimate. The estimate includes the size of all the items in
+     * the table, plus the size of all attributes projected into all of the local
+     * secondary indexes on that table. Use this estimate to measure whether a local
+     * secondary index is approaching its size limit.</p> <p>The estimate is subject to
+     * change over time; therefore, do not rely on the precision or accuracy of the
+     * estimate.</p> </li> </ul>
+     */
+    inline void SetItemCollectionMetrics(const ItemCollectionMetrics& value) { m_itemCollectionMetrics = value; }
+
+    /**
+     * <p>Information about item collections, if any, that were affected by the
+     * <code>DeleteItem</code> operation. <code>ItemCollectionMetrics</code> is only
+     * returned if the <code>ReturnItemCollectionMetrics</code> parameter was
+     * specified. If the table does not have any local secondary indexes, this
+     * information is not returned in the response.</p> <p>Each
+     * <code>ItemCollectionMetrics</code> element consists of:</p> <ul> <li> <p>
+     * <code>ItemCollectionKey</code> - The partition key value of the item collection.
+     * This is the same as the partition key value of the item itself.</p> </li> <li>
+     * <p> <code>SizeEstimateRangeGB</code> - An estimate of item collection size, in
+     * gigabytes. This value is a two-element array containing a lower bound and an
+     * upper bound for the estimate. The estimate includes the size of all the items in
+     * the table, plus the size of all attributes projected into all of the local
+     * secondary indexes on that table. Use this estimate to measure whether a local
+     * secondary index is approaching its size limit.</p> <p>The estimate is subject to
+     * change over time; therefore, do not rely on the precision or accuracy of the
+     * estimate.</p> </li> </ul>
+     */
+    inline void SetItemCollectionMetrics(ItemCollectionMetrics&& value) { m_itemCollectionMetrics = std::move(value); }
+
+    /**
+     * <p>Information about item collections, if any, that were affected by the
+     * <code>DeleteItem</code> operation. <code>ItemCollectionMetrics</code> is only
+     * returned if the <code>ReturnItemCollectionMetrics</code> parameter was
+     * specified. If the table does not have any local secondary indexes, this
+     * information is not returned in the response.</p> <p>Each
+     * <code>ItemCollectionMetrics</code> element consists of:</p> <ul> <li> <p>
+     * <code>ItemCollectionKey</code> - The partition key value of the item collection.
+     * This is the same as the partition key value of the item itself.</p> </li> <li>
+     * <p> <code>SizeEstimateRangeGB</code> - An estimate of item collection size, in
+     * gigabytes. This value is a two-element array containing a lower bound and an
+     * upper bound for the estimate. The estimate includes the size of all the items in
+     * the table, plus the size of all attributes projected into all of the local
+     * secondary indexes on that table. Use this estimate to measure whether a local
+     * secondary index is approaching its size limit.</p> <p>The estimate is subject to
+     * change over time; therefore, do not rely on the precision or accuracy of the
+     * estimate.</p> </li> </ul>
+     */
+    inline DeleteItemResult& WithItemCollectionMetrics(const ItemCollectionMetrics& value) { SetItemCollectionMetrics(value); return *this;}
+
+    /**
+     * <p>Information about item collections, if any, that were affected by the
+     * <code>DeleteItem</code> operation. <code>ItemCollectionMetrics</code> is only
+     * returned if the <code>ReturnItemCollectionMetrics</code> parameter was
+     * specified. If the table does not have any local secondary indexes, this
+     * information is not returned in the response.</p> <p>Each
+     * <code>ItemCollectionMetrics</code> element consists of:</p> <ul> <li> <p>
+     * <code>ItemCollectionKey</code> - The partition key value of the item collection.
+     * This is the same as the partition key value of the item itself.</p> </li> <li>
+     * <p> <code>SizeEstimateRangeGB</code> - An estimate of item collection size, in
+     * gigabytes. This value is a two-element array containing a lower bound and an
+     * upper bound for the estimate. The estimate includes the size of all the items in
+     * the table, plus the size of all attributes projected into all of the local
+     * secondary indexes on that table. Use this estimate to measure whether a local
+     * secondary index is approaching its size limit.</p> <p>The estimate is subject to
+     * change over time; therefore, do not rely on the precision or accuracy of the
+     * estimate.</p> </li> </ul>
+     */
+    inline DeleteItemResult& WithItemCollectionMetrics(ItemCollectionMetrics&& value) { SetItemCollectionMetrics(std::move(value)); return *this;}
+
+  private:
+
+    Aws::Map<Aws::String, AttributeValue> m_attributes;
+
+    ConsumedCapacity m_consumedCapacity;
+
+    ItemCollectionMetrics m_itemCollectionMetrics;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DeleteReplicaAction.h

@@ -0,0 +1,88 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents a replica to be removed.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DeleteReplicaAction">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API DeleteReplicaAction
+  {
+  public:
+    DeleteReplicaAction();
+    DeleteReplicaAction(Aws::Utils::Json::JsonView jsonValue);
+    DeleteReplicaAction& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The Region of the replica to be removed.</p>
+     */
+    inline const Aws::String& GetRegionName() const{ return m_regionName; }
+
+    /**
+     * <p>The Region of the replica to be removed.</p>
+     */
+    inline bool RegionNameHasBeenSet() const { return m_regionNameHasBeenSet; }
+
+    /**
+     * <p>The Region of the replica to be removed.</p>
+     */
+    inline void SetRegionName(const Aws::String& value) { m_regionNameHasBeenSet = true; m_regionName = value; }
+
+    /**
+     * <p>The Region of the replica to be removed.</p>
+     */
+    inline void SetRegionName(Aws::String&& value) { m_regionNameHasBeenSet = true; m_regionName = std::move(value); }
+
+    /**
+     * <p>The Region of the replica to be removed.</p>
+     */
+    inline void SetRegionName(const char* value) { m_regionNameHasBeenSet = true; m_regionName.assign(value); }
+
+    /**
+     * <p>The Region of the replica to be removed.</p>
+     */
+    inline DeleteReplicaAction& WithRegionName(const Aws::String& value) { SetRegionName(value); return *this;}
+
+    /**
+     * <p>The Region of the replica to be removed.</p>
+     */
+    inline DeleteReplicaAction& WithRegionName(Aws::String&& value) { SetRegionName(std::move(value)); return *this;}
+
+    /**
+     * <p>The Region of the replica to be removed.</p>
+     */
+    inline DeleteReplicaAction& WithRegionName(const char* value) { SetRegionName(value); return *this;}
+
+  private:
+
+    Aws::String m_regionName;
+    bool m_regionNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DeleteReplicationGroupMemberAction.h

@@ -0,0 +1,88 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents a replica to be deleted.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DeleteReplicationGroupMemberAction">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API DeleteReplicationGroupMemberAction
+  {
+  public:
+    DeleteReplicationGroupMemberAction();
+    DeleteReplicationGroupMemberAction(Aws::Utils::Json::JsonView jsonValue);
+    DeleteReplicationGroupMemberAction& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The Region where the replica exists.</p>
+     */
+    inline const Aws::String& GetRegionName() const{ return m_regionName; }
+
+    /**
+     * <p>The Region where the replica exists.</p>
+     */
+    inline bool RegionNameHasBeenSet() const { return m_regionNameHasBeenSet; }
+
+    /**
+     * <p>The Region where the replica exists.</p>
+     */
+    inline void SetRegionName(const Aws::String& value) { m_regionNameHasBeenSet = true; m_regionName = value; }
+
+    /**
+     * <p>The Region where the replica exists.</p>
+     */
+    inline void SetRegionName(Aws::String&& value) { m_regionNameHasBeenSet = true; m_regionName = std::move(value); }
+
+    /**
+     * <p>The Region where the replica exists.</p>
+     */
+    inline void SetRegionName(const char* value) { m_regionNameHasBeenSet = true; m_regionName.assign(value); }
+
+    /**
+     * <p>The Region where the replica exists.</p>
+     */
+    inline DeleteReplicationGroupMemberAction& WithRegionName(const Aws::String& value) { SetRegionName(value); return *this;}
+
+    /**
+     * <p>The Region where the replica exists.</p>
+     */
+    inline DeleteReplicationGroupMemberAction& WithRegionName(Aws::String&& value) { SetRegionName(std::move(value)); return *this;}
+
+    /**
+     * <p>The Region where the replica exists.</p>
+     */
+    inline DeleteReplicationGroupMemberAction& WithRegionName(const char* value) { SetRegionName(value); return *this;}
+
+  private:
+
+    Aws::String m_regionName;
+    bool m_regionNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DeleteRequest.h

@@ -0,0 +1,135 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/dynamodb/model/AttributeValue.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents a request to perform a <code>DeleteItem</code> operation on an
+   * item.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DeleteRequest">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API DeleteRequest
+  {
+  public:
+    DeleteRequest();
+    DeleteRequest(Aws::Utils::Json::JsonView jsonValue);
+    DeleteRequest& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>A map of attribute name to attribute values, representing the primary key of
+     * the item to delete. All of the table's primary key attributes must be specified,
+     * and their data types must match those of the table's key schema.</p>
+     */
+    inline const Aws::Map<Aws::String, AttributeValue>& GetKey() const{ return m_key; }
+
+    /**
+     * <p>A map of attribute name to attribute values, representing the primary key of
+     * the item to delete. All of the table's primary key attributes must be specified,
+     * and their data types must match those of the table's key schema.</p>
+     */
+    inline bool KeyHasBeenSet() const { return m_keyHasBeenSet; }
+
+    /**
+     * <p>A map of attribute name to attribute values, representing the primary key of
+     * the item to delete. All of the table's primary key attributes must be specified,
+     * and their data types must match those of the table's key schema.</p>
+     */
+    inline void SetKey(const Aws::Map<Aws::String, AttributeValue>& value) { m_keyHasBeenSet = true; m_key = value; }
+
+    /**
+     * <p>A map of attribute name to attribute values, representing the primary key of
+     * the item to delete. All of the table's primary key attributes must be specified,
+     * and their data types must match those of the table's key schema.</p>
+     */
+    inline void SetKey(Aws::Map<Aws::String, AttributeValue>&& value) { m_keyHasBeenSet = true; m_key = std::move(value); }
+
+    /**
+     * <p>A map of attribute name to attribute values, representing the primary key of
+     * the item to delete. All of the table's primary key attributes must be specified,
+     * and their data types must match those of the table's key schema.</p>
+     */
+    inline DeleteRequest& WithKey(const Aws::Map<Aws::String, AttributeValue>& value) { SetKey(value); return *this;}
+
+    /**
+     * <p>A map of attribute name to attribute values, representing the primary key of
+     * the item to delete. All of the table's primary key attributes must be specified,
+     * and their data types must match those of the table's key schema.</p>
+     */
+    inline DeleteRequest& WithKey(Aws::Map<Aws::String, AttributeValue>&& value) { SetKey(std::move(value)); return *this;}
+
+    /**
+     * <p>A map of attribute name to attribute values, representing the primary key of
+     * the item to delete. All of the table's primary key attributes must be specified,
+     * and their data types must match those of the table's key schema.</p>
+     */
+    inline DeleteRequest& AddKey(const Aws::String& key, const AttributeValue& value) { m_keyHasBeenSet = true; m_key.emplace(key, value); return *this; }
+
+    /**
+     * <p>A map of attribute name to attribute values, representing the primary key of
+     * the item to delete. All of the table's primary key attributes must be specified,
+     * and their data types must match those of the table's key schema.</p>
+     */
+    inline DeleteRequest& AddKey(Aws::String&& key, const AttributeValue& value) { m_keyHasBeenSet = true; m_key.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>A map of attribute name to attribute values, representing the primary key of
+     * the item to delete. All of the table's primary key attributes must be specified,
+     * and their data types must match those of the table's key schema.</p>
+     */
+    inline DeleteRequest& AddKey(const Aws::String& key, AttributeValue&& value) { m_keyHasBeenSet = true; m_key.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A map of attribute name to attribute values, representing the primary key of
+     * the item to delete. All of the table's primary key attributes must be specified,
+     * and their data types must match those of the table's key schema.</p>
+     */
+    inline DeleteRequest& AddKey(Aws::String&& key, AttributeValue&& value) { m_keyHasBeenSet = true; m_key.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>A map of attribute name to attribute values, representing the primary key of
+     * the item to delete. All of the table's primary key attributes must be specified,
+     * and their data types must match those of the table's key schema.</p>
+     */
+    inline DeleteRequest& AddKey(const char* key, AttributeValue&& value) { m_keyHasBeenSet = true; m_key.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A map of attribute name to attribute values, representing the primary key of
+     * the item to delete. All of the table's primary key attributes must be specified,
+     * and their data types must match those of the table's key schema.</p>
+     */
+    inline DeleteRequest& AddKey(const char* key, const AttributeValue& value) { m_keyHasBeenSet = true; m_key.emplace(key, value); return *this; }
+
+  private:
+
+    Aws::Map<Aws::String, AttributeValue> m_key;
+    bool m_keyHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DeleteTableRequest.h

@@ -0,0 +1,89 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/DynamoDBRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents the input of a <code>DeleteTable</code> operation.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DeleteTableInput">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API DeleteTableRequest : public DynamoDBRequest
+  {
+  public:
+    DeleteTableRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DeleteTable"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the table to delete.</p>
+     */
+    inline const Aws::String& GetTableName() const{ return m_tableName; }
+
+    /**
+     * <p>The name of the table to delete.</p>
+     */
+    inline bool TableNameHasBeenSet() const { return m_tableNameHasBeenSet; }
+
+    /**
+     * <p>The name of the table to delete.</p>
+     */
+    inline void SetTableName(const Aws::String& value) { m_tableNameHasBeenSet = true; m_tableName = value; }
+
+    /**
+     * <p>The name of the table to delete.</p>
+     */
+    inline void SetTableName(Aws::String&& value) { m_tableNameHasBeenSet = true; m_tableName = std::move(value); }
+
+    /**
+     * <p>The name of the table to delete.</p>
+     */
+    inline void SetTableName(const char* value) { m_tableNameHasBeenSet = true; m_tableName.assign(value); }
+
+    /**
+     * <p>The name of the table to delete.</p>
+     */
+    inline DeleteTableRequest& WithTableName(const Aws::String& value) { SetTableName(value); return *this;}
+
+    /**
+     * <p>The name of the table to delete.</p>
+     */
+    inline DeleteTableRequest& WithTableName(Aws::String&& value) { SetTableName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the table to delete.</p>
+     */
+    inline DeleteTableRequest& WithTableName(const char* value) { SetTableName(value); return *this;}
+
+  private:
+
+    Aws::String m_tableName;
+    bool m_tableNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DeleteTableResult.h

@@ -0,0 +1,73 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/model/TableDescription.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+  /**
+   * <p>Represents the output of a <code>DeleteTable</code> operation.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DeleteTableOutput">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API DeleteTableResult
+  {
+  public:
+    DeleteTableResult();
+    DeleteTableResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DeleteTableResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Represents the properties of a table.</p>
+     */
+    inline const TableDescription& GetTableDescription() const{ return m_tableDescription; }
+
+    /**
+     * <p>Represents the properties of a table.</p>
+     */
+    inline void SetTableDescription(const TableDescription& value) { m_tableDescription = value; }
+
+    /**
+     * <p>Represents the properties of a table.</p>
+     */
+    inline void SetTableDescription(TableDescription&& value) { m_tableDescription = std::move(value); }
+
+    /**
+     * <p>Represents the properties of a table.</p>
+     */
+    inline DeleteTableResult& WithTableDescription(const TableDescription& value) { SetTableDescription(value); return *this;}
+
+    /**
+     * <p>Represents the properties of a table.</p>
+     */
+    inline DeleteTableResult& WithTableDescription(TableDescription&& value) { SetTableDescription(std::move(value)); return *this;}
+
+  private:
+
+    TableDescription m_tableDescription;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DescribeBackupRequest.h

@@ -0,0 +1,85 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/DynamoDBRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DYNAMODB_API DescribeBackupRequest : public DynamoDBRequest
+  {
+  public:
+    DescribeBackupRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DescribeBackup"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) associated with the backup.</p>
+     */
+    inline const Aws::String& GetBackupArn() const{ return m_backupArn; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) associated with the backup.</p>
+     */
+    inline bool BackupArnHasBeenSet() const { return m_backupArnHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) associated with the backup.</p>
+     */
+    inline void SetBackupArn(const Aws::String& value) { m_backupArnHasBeenSet = true; m_backupArn = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) associated with the backup.</p>
+     */
+    inline void SetBackupArn(Aws::String&& value) { m_backupArnHasBeenSet = true; m_backupArn = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) associated with the backup.</p>
+     */
+    inline void SetBackupArn(const char* value) { m_backupArnHasBeenSet = true; m_backupArn.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) associated with the backup.</p>
+     */
+    inline DescribeBackupRequest& WithBackupArn(const Aws::String& value) { SetBackupArn(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) associated with the backup.</p>
+     */
+    inline DescribeBackupRequest& WithBackupArn(Aws::String&& value) { SetBackupArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) associated with the backup.</p>
+     */
+    inline DescribeBackupRequest& WithBackupArn(const char* value) { SetBackupArn(value); return *this;}
+
+  private:
+
+    Aws::String m_backupArn;
+    bool m_backupArnHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DescribeBackupResult.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/model/BackupDescription.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+  class AWS_DYNAMODB_API DescribeBackupResult
+  {
+  public:
+    DescribeBackupResult();
+    DescribeBackupResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DescribeBackupResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Contains the description of the backup created for the table.</p>
+     */
+    inline const BackupDescription& GetBackupDescription() const{ return m_backupDescription; }
+
+    /**
+     * <p>Contains the description of the backup created for the table.</p>
+     */
+    inline void SetBackupDescription(const BackupDescription& value) { m_backupDescription = value; }
+
+    /**
+     * <p>Contains the description of the backup created for the table.</p>
+     */
+    inline void SetBackupDescription(BackupDescription&& value) { m_backupDescription = std::move(value); }
+
+    /**
+     * <p>Contains the description of the backup created for the table.</p>
+     */
+    inline DescribeBackupResult& WithBackupDescription(const BackupDescription& value) { SetBackupDescription(value); return *this;}
+
+    /**
+     * <p>Contains the description of the backup created for the table.</p>
+     */
+    inline DescribeBackupResult& WithBackupDescription(BackupDescription&& value) { SetBackupDescription(std::move(value)); return *this;}
+
+  private:
+
+    BackupDescription m_backupDescription;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DescribeContinuousBackupsRequest.h

@@ -0,0 +1,93 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/DynamoDBRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DYNAMODB_API DescribeContinuousBackupsRequest : public DynamoDBRequest
+  {
+  public:
+    DescribeContinuousBackupsRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DescribeContinuousBackups"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>Name of the table for which the customer wants to check the continuous
+     * backups and point in time recovery settings.</p>
+     */
+    inline const Aws::String& GetTableName() const{ return m_tableName; }
+
+    /**
+     * <p>Name of the table for which the customer wants to check the continuous
+     * backups and point in time recovery settings.</p>
+     */
+    inline bool TableNameHasBeenSet() const { return m_tableNameHasBeenSet; }
+
+    /**
+     * <p>Name of the table for which the customer wants to check the continuous
+     * backups and point in time recovery settings.</p>
+     */
+    inline void SetTableName(const Aws::String& value) { m_tableNameHasBeenSet = true; m_tableName = value; }
+
+    /**
+     * <p>Name of the table for which the customer wants to check the continuous
+     * backups and point in time recovery settings.</p>
+     */
+    inline void SetTableName(Aws::String&& value) { m_tableNameHasBeenSet = true; m_tableName = std::move(value); }
+
+    /**
+     * <p>Name of the table for which the customer wants to check the continuous
+     * backups and point in time recovery settings.</p>
+     */
+    inline void SetTableName(const char* value) { m_tableNameHasBeenSet = true; m_tableName.assign(value); }
+
+    /**
+     * <p>Name of the table for which the customer wants to check the continuous
+     * backups and point in time recovery settings.</p>
+     */
+    inline DescribeContinuousBackupsRequest& WithTableName(const Aws::String& value) { SetTableName(value); return *this;}
+
+    /**
+     * <p>Name of the table for which the customer wants to check the continuous
+     * backups and point in time recovery settings.</p>
+     */
+    inline DescribeContinuousBackupsRequest& WithTableName(Aws::String&& value) { SetTableName(std::move(value)); return *this;}
+
+    /**
+     * <p>Name of the table for which the customer wants to check the continuous
+     * backups and point in time recovery settings.</p>
+     */
+    inline DescribeContinuousBackupsRequest& WithTableName(const char* value) { SetTableName(value); return *this;}
+
+  private:
+
+    Aws::String m_tableName;
+    bool m_tableNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DescribeContinuousBackupsResult.h

@@ -0,0 +1,72 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/model/ContinuousBackupsDescription.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+  class AWS_DYNAMODB_API DescribeContinuousBackupsResult
+  {
+  public:
+    DescribeContinuousBackupsResult();
+    DescribeContinuousBackupsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DescribeContinuousBackupsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Represents the continuous backups and point in time recovery settings on the
+     * table.</p>
+     */
+    inline const ContinuousBackupsDescription& GetContinuousBackupsDescription() const{ return m_continuousBackupsDescription; }
+
+    /**
+     * <p>Represents the continuous backups and point in time recovery settings on the
+     * table.</p>
+     */
+    inline void SetContinuousBackupsDescription(const ContinuousBackupsDescription& value) { m_continuousBackupsDescription = value; }
+
+    /**
+     * <p>Represents the continuous backups and point in time recovery settings on the
+     * table.</p>
+     */
+    inline void SetContinuousBackupsDescription(ContinuousBackupsDescription&& value) { m_continuousBackupsDescription = std::move(value); }
+
+    /**
+     * <p>Represents the continuous backups and point in time recovery settings on the
+     * table.</p>
+     */
+    inline DescribeContinuousBackupsResult& WithContinuousBackupsDescription(const ContinuousBackupsDescription& value) { SetContinuousBackupsDescription(value); return *this;}
+
+    /**
+     * <p>Represents the continuous backups and point in time recovery settings on the
+     * table.</p>
+     */
+    inline DescribeContinuousBackupsResult& WithContinuousBackupsDescription(ContinuousBackupsDescription&& value) { SetContinuousBackupsDescription(std::move(value)); return *this;}
+
+  private:
+
+    ContinuousBackupsDescription m_continuousBackupsDescription;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DescribeContributorInsightsRequest.h

@@ -0,0 +1,129 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/DynamoDBRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DYNAMODB_API DescribeContributorInsightsRequest : public DynamoDBRequest
+  {
+  public:
+    DescribeContributorInsightsRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DescribeContributorInsights"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the table to describe.</p>
+     */
+    inline const Aws::String& GetTableName() const{ return m_tableName; }
+
+    /**
+     * <p>The name of the table to describe.</p>
+     */
+    inline bool TableNameHasBeenSet() const { return m_tableNameHasBeenSet; }
+
+    /**
+     * <p>The name of the table to describe.</p>
+     */
+    inline void SetTableName(const Aws::String& value) { m_tableNameHasBeenSet = true; m_tableName = value; }
+
+    /**
+     * <p>The name of the table to describe.</p>
+     */
+    inline void SetTableName(Aws::String&& value) { m_tableNameHasBeenSet = true; m_tableName = std::move(value); }
+
+    /**
+     * <p>The name of the table to describe.</p>
+     */
+    inline void SetTableName(const char* value) { m_tableNameHasBeenSet = true; m_tableName.assign(value); }
+
+    /**
+     * <p>The name of the table to describe.</p>
+     */
+    inline DescribeContributorInsightsRequest& WithTableName(const Aws::String& value) { SetTableName(value); return *this;}
+
+    /**
+     * <p>The name of the table to describe.</p>
+     */
+    inline DescribeContributorInsightsRequest& WithTableName(Aws::String&& value) { SetTableName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the table to describe.</p>
+     */
+    inline DescribeContributorInsightsRequest& WithTableName(const char* value) { SetTableName(value); return *this;}
+
+
+    /**
+     * <p>The name of the global secondary index to describe, if applicable.</p>
+     */
+    inline const Aws::String& GetIndexName() const{ return m_indexName; }
+
+    /**
+     * <p>The name of the global secondary index to describe, if applicable.</p>
+     */
+    inline bool IndexNameHasBeenSet() const { return m_indexNameHasBeenSet; }
+
+    /**
+     * <p>The name of the global secondary index to describe, if applicable.</p>
+     */
+    inline void SetIndexName(const Aws::String& value) { m_indexNameHasBeenSet = true; m_indexName = value; }
+
+    /**
+     * <p>The name of the global secondary index to describe, if applicable.</p>
+     */
+    inline void SetIndexName(Aws::String&& value) { m_indexNameHasBeenSet = true; m_indexName = std::move(value); }
+
+    /**
+     * <p>The name of the global secondary index to describe, if applicable.</p>
+     */
+    inline void SetIndexName(const char* value) { m_indexNameHasBeenSet = true; m_indexName.assign(value); }
+
+    /**
+     * <p>The name of the global secondary index to describe, if applicable.</p>
+     */
+    inline DescribeContributorInsightsRequest& WithIndexName(const Aws::String& value) { SetIndexName(value); return *this;}
+
+    /**
+     * <p>The name of the global secondary index to describe, if applicable.</p>
+     */
+    inline DescribeContributorInsightsRequest& WithIndexName(Aws::String&& value) { SetIndexName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the global secondary index to describe, if applicable.</p>
+     */
+    inline DescribeContributorInsightsRequest& WithIndexName(const char* value) { SetIndexName(value); return *this;}
+
+  private:
+
+    Aws::String m_tableName;
+    bool m_tableNameHasBeenSet;
+
+    Aws::String m_indexName;
+    bool m_indexNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DescribeContributorInsightsResult.h

@@ -0,0 +1,296 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/dynamodb/model/ContributorInsightsStatus.h>
+#include <aws/core/utils/DateTime.h>
+#include <aws/dynamodb/model/FailureException.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+  class AWS_DYNAMODB_API DescribeContributorInsightsResult
+  {
+  public:
+    DescribeContributorInsightsResult();
+    DescribeContributorInsightsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DescribeContributorInsightsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The name of the table being described.</p>
+     */
+    inline const Aws::String& GetTableName() const{ return m_tableName; }
+
+    /**
+     * <p>The name of the table being described.</p>
+     */
+    inline void SetTableName(const Aws::String& value) { m_tableName = value; }
+
+    /**
+     * <p>The name of the table being described.</p>
+     */
+    inline void SetTableName(Aws::String&& value) { m_tableName = std::move(value); }
+
+    /**
+     * <p>The name of the table being described.</p>
+     */
+    inline void SetTableName(const char* value) { m_tableName.assign(value); }
+
+    /**
+     * <p>The name of the table being described.</p>
+     */
+    inline DescribeContributorInsightsResult& WithTableName(const Aws::String& value) { SetTableName(value); return *this;}
+
+    /**
+     * <p>The name of the table being described.</p>
+     */
+    inline DescribeContributorInsightsResult& WithTableName(Aws::String&& value) { SetTableName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the table being described.</p>
+     */
+    inline DescribeContributorInsightsResult& WithTableName(const char* value) { SetTableName(value); return *this;}
+
+
+    /**
+     * <p>The name of the global secondary index being described.</p>
+     */
+    inline const Aws::String& GetIndexName() const{ return m_indexName; }
+
+    /**
+     * <p>The name of the global secondary index being described.</p>
+     */
+    inline void SetIndexName(const Aws::String& value) { m_indexName = value; }
+
+    /**
+     * <p>The name of the global secondary index being described.</p>
+     */
+    inline void SetIndexName(Aws::String&& value) { m_indexName = std::move(value); }
+
+    /**
+     * <p>The name of the global secondary index being described.</p>
+     */
+    inline void SetIndexName(const char* value) { m_indexName.assign(value); }
+
+    /**
+     * <p>The name of the global secondary index being described.</p>
+     */
+    inline DescribeContributorInsightsResult& WithIndexName(const Aws::String& value) { SetIndexName(value); return *this;}
+
+    /**
+     * <p>The name of the global secondary index being described.</p>
+     */
+    inline DescribeContributorInsightsResult& WithIndexName(Aws::String&& value) { SetIndexName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the global secondary index being described.</p>
+     */
+    inline DescribeContributorInsightsResult& WithIndexName(const char* value) { SetIndexName(value); return *this;}
+
+
+    /**
+     * <p>List of names of the associated Alpine rules.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetContributorInsightsRuleList() const{ return m_contributorInsightsRuleList; }
+
+    /**
+     * <p>List of names of the associated Alpine rules.</p>
+     */
+    inline void SetContributorInsightsRuleList(const Aws::Vector<Aws::String>& value) { m_contributorInsightsRuleList = value; }
+
+    /**
+     * <p>List of names of the associated Alpine rules.</p>
+     */
+    inline void SetContributorInsightsRuleList(Aws::Vector<Aws::String>&& value) { m_contributorInsightsRuleList = std::move(value); }
+
+    /**
+     * <p>List of names of the associated Alpine rules.</p>
+     */
+    inline DescribeContributorInsightsResult& WithContributorInsightsRuleList(const Aws::Vector<Aws::String>& value) { SetContributorInsightsRuleList(value); return *this;}
+
+    /**
+     * <p>List of names of the associated Alpine rules.</p>
+     */
+    inline DescribeContributorInsightsResult& WithContributorInsightsRuleList(Aws::Vector<Aws::String>&& value) { SetContributorInsightsRuleList(std::move(value)); return *this;}
+
+    /**
+     * <p>List of names of the associated Alpine rules.</p>
+     */
+    inline DescribeContributorInsightsResult& AddContributorInsightsRuleList(const Aws::String& value) { m_contributorInsightsRuleList.push_back(value); return *this; }
+
+    /**
+     * <p>List of names of the associated Alpine rules.</p>
+     */
+    inline DescribeContributorInsightsResult& AddContributorInsightsRuleList(Aws::String&& value) { m_contributorInsightsRuleList.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>List of names of the associated Alpine rules.</p>
+     */
+    inline DescribeContributorInsightsResult& AddContributorInsightsRuleList(const char* value) { m_contributorInsightsRuleList.push_back(value); return *this; }
+
+
+    /**
+     * <p>Current Status contributor insights.</p>
+     */
+    inline const ContributorInsightsStatus& GetContributorInsightsStatus() const{ return m_contributorInsightsStatus; }
+
+    /**
+     * <p>Current Status contributor insights.</p>
+     */
+    inline void SetContributorInsightsStatus(const ContributorInsightsStatus& value) { m_contributorInsightsStatus = value; }
+
+    /**
+     * <p>Current Status contributor insights.</p>
+     */
+    inline void SetContributorInsightsStatus(ContributorInsightsStatus&& value) { m_contributorInsightsStatus = std::move(value); }
+
+    /**
+     * <p>Current Status contributor insights.</p>
+     */
+    inline DescribeContributorInsightsResult& WithContributorInsightsStatus(const ContributorInsightsStatus& value) { SetContributorInsightsStatus(value); return *this;}
+
+    /**
+     * <p>Current Status contributor insights.</p>
+     */
+    inline DescribeContributorInsightsResult& WithContributorInsightsStatus(ContributorInsightsStatus&& value) { SetContributorInsightsStatus(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Timestamp of the last time the status was changed.</p>
+     */
+    inline const Aws::Utils::DateTime& GetLastUpdateDateTime() const{ return m_lastUpdateDateTime; }
+
+    /**
+     * <p>Timestamp of the last time the status was changed.</p>
+     */
+    inline void SetLastUpdateDateTime(const Aws::Utils::DateTime& value) { m_lastUpdateDateTime = value; }
+
+    /**
+     * <p>Timestamp of the last time the status was changed.</p>
+     */
+    inline void SetLastUpdateDateTime(Aws::Utils::DateTime&& value) { m_lastUpdateDateTime = std::move(value); }
+
+    /**
+     * <p>Timestamp of the last time the status was changed.</p>
+     */
+    inline DescribeContributorInsightsResult& WithLastUpdateDateTime(const Aws::Utils::DateTime& value) { SetLastUpdateDateTime(value); return *this;}
+
+    /**
+     * <p>Timestamp of the last time the status was changed.</p>
+     */
+    inline DescribeContributorInsightsResult& WithLastUpdateDateTime(Aws::Utils::DateTime&& value) { SetLastUpdateDateTime(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Returns information about the last failure that encountered.</p> <p>The most
+     * common exceptions for a FAILED status are:</p> <ul> <li>
+     * <p>LimitExceededException - Per-account Amazon CloudWatch Contributor Insights
+     * rule limit reached. Please disable Contributor Insights for other tables/indexes
+     * OR disable Contributor Insights rules before retrying.</p> </li> <li>
+     * <p>AccessDeniedException - Amazon CloudWatch Contributor Insights rules cannot
+     * be modified due to insufficient permissions.</p> </li> <li>
+     * <p>AccessDeniedException - Failed to create service-linked role for Contributor
+     * Insights due to insufficient permissions.</p> </li> <li> <p>InternalServerError
+     * - Failed to create Amazon CloudWatch Contributor Insights rules. Please retry
+     * request.</p> </li> </ul>
+     */
+    inline const FailureException& GetFailureException() const{ return m_failureException; }
+
+    /**
+     * <p>Returns information about the last failure that encountered.</p> <p>The most
+     * common exceptions for a FAILED status are:</p> <ul> <li>
+     * <p>LimitExceededException - Per-account Amazon CloudWatch Contributor Insights
+     * rule limit reached. Please disable Contributor Insights for other tables/indexes
+     * OR disable Contributor Insights rules before retrying.</p> </li> <li>
+     * <p>AccessDeniedException - Amazon CloudWatch Contributor Insights rules cannot
+     * be modified due to insufficient permissions.</p> </li> <li>
+     * <p>AccessDeniedException - Failed to create service-linked role for Contributor
+     * Insights due to insufficient permissions.</p> </li> <li> <p>InternalServerError
+     * - Failed to create Amazon CloudWatch Contributor Insights rules. Please retry
+     * request.</p> </li> </ul>
+     */
+    inline void SetFailureException(const FailureException& value) { m_failureException = value; }
+
+    /**
+     * <p>Returns information about the last failure that encountered.</p> <p>The most
+     * common exceptions for a FAILED status are:</p> <ul> <li>
+     * <p>LimitExceededException - Per-account Amazon CloudWatch Contributor Insights
+     * rule limit reached. Please disable Contributor Insights for other tables/indexes
+     * OR disable Contributor Insights rules before retrying.</p> </li> <li>
+     * <p>AccessDeniedException - Amazon CloudWatch Contributor Insights rules cannot
+     * be modified due to insufficient permissions.</p> </li> <li>
+     * <p>AccessDeniedException - Failed to create service-linked role for Contributor
+     * Insights due to insufficient permissions.</p> </li> <li> <p>InternalServerError
+     * - Failed to create Amazon CloudWatch Contributor Insights rules. Please retry
+     * request.</p> </li> </ul>
+     */
+    inline void SetFailureException(FailureException&& value) { m_failureException = std::move(value); }
+
+    /**
+     * <p>Returns information about the last failure that encountered.</p> <p>The most
+     * common exceptions for a FAILED status are:</p> <ul> <li>
+     * <p>LimitExceededException - Per-account Amazon CloudWatch Contributor Insights
+     * rule limit reached. Please disable Contributor Insights for other tables/indexes
+     * OR disable Contributor Insights rules before retrying.</p> </li> <li>
+     * <p>AccessDeniedException - Amazon CloudWatch Contributor Insights rules cannot
+     * be modified due to insufficient permissions.</p> </li> <li>
+     * <p>AccessDeniedException - Failed to create service-linked role for Contributor
+     * Insights due to insufficient permissions.</p> </li> <li> <p>InternalServerError
+     * - Failed to create Amazon CloudWatch Contributor Insights rules. Please retry
+     * request.</p> </li> </ul>
+     */
+    inline DescribeContributorInsightsResult& WithFailureException(const FailureException& value) { SetFailureException(value); return *this;}
+
+    /**
+     * <p>Returns information about the last failure that encountered.</p> <p>The most
+     * common exceptions for a FAILED status are:</p> <ul> <li>
+     * <p>LimitExceededException - Per-account Amazon CloudWatch Contributor Insights
+     * rule limit reached. Please disable Contributor Insights for other tables/indexes
+     * OR disable Contributor Insights rules before retrying.</p> </li> <li>
+     * <p>AccessDeniedException - Amazon CloudWatch Contributor Insights rules cannot
+     * be modified due to insufficient permissions.</p> </li> <li>
+     * <p>AccessDeniedException - Failed to create service-linked role for Contributor
+     * Insights due to insufficient permissions.</p> </li> <li> <p>InternalServerError
+     * - Failed to create Amazon CloudWatch Contributor Insights rules. Please retry
+     * request.</p> </li> </ul>
+     */
+    inline DescribeContributorInsightsResult& WithFailureException(FailureException&& value) { SetFailureException(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_tableName;
+
+    Aws::String m_indexName;
+
+    Aws::Vector<Aws::String> m_contributorInsightsRuleList;
+
+    ContributorInsightsStatus m_contributorInsightsStatus;
+
+    Aws::Utils::DateTime m_lastUpdateDateTime;
+
+    FailureException m_failureException;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DescribeEndpointsRequest.h

@@ -0,0 +1,38 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/DynamoDBRequest.h>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DYNAMODB_API DescribeEndpointsRequest : public DynamoDBRequest
+  {
+  public:
+    DescribeEndpointsRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DescribeEndpoints"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DescribeEndpointsResult.h

@@ -0,0 +1,78 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/dynamodb/model/Endpoint.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+  class AWS_DYNAMODB_API DescribeEndpointsResult
+  {
+  public:
+    DescribeEndpointsResult();
+    DescribeEndpointsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DescribeEndpointsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>List of endpoints.</p>
+     */
+    inline const Aws::Vector<Endpoint>& GetEndpoints() const{ return m_endpoints; }
+
+    /**
+     * <p>List of endpoints.</p>
+     */
+    inline void SetEndpoints(const Aws::Vector<Endpoint>& value) { m_endpoints = value; }
+
+    /**
+     * <p>List of endpoints.</p>
+     */
+    inline void SetEndpoints(Aws::Vector<Endpoint>&& value) { m_endpoints = std::move(value); }
+
+    /**
+     * <p>List of endpoints.</p>
+     */
+    inline DescribeEndpointsResult& WithEndpoints(const Aws::Vector<Endpoint>& value) { SetEndpoints(value); return *this;}
+
+    /**
+     * <p>List of endpoints.</p>
+     */
+    inline DescribeEndpointsResult& WithEndpoints(Aws::Vector<Endpoint>&& value) { SetEndpoints(std::move(value)); return *this;}
+
+    /**
+     * <p>List of endpoints.</p>
+     */
+    inline DescribeEndpointsResult& AddEndpoints(const Endpoint& value) { m_endpoints.push_back(value); return *this; }
+
+    /**
+     * <p>List of endpoints.</p>
+     */
+    inline DescribeEndpointsResult& AddEndpoints(Endpoint&& value) { m_endpoints.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::Vector<Endpoint> m_endpoints;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DescribeGlobalTableRequest.h

@@ -0,0 +1,85 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/DynamoDBRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DYNAMODB_API DescribeGlobalTableRequest : public DynamoDBRequest
+  {
+  public:
+    DescribeGlobalTableRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DescribeGlobalTable"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the global table.</p>
+     */
+    inline const Aws::String& GetGlobalTableName() const{ return m_globalTableName; }
+
+    /**
+     * <p>The name of the global table.</p>
+     */
+    inline bool GlobalTableNameHasBeenSet() const { return m_globalTableNameHasBeenSet; }
+
+    /**
+     * <p>The name of the global table.</p>
+     */
+    inline void SetGlobalTableName(const Aws::String& value) { m_globalTableNameHasBeenSet = true; m_globalTableName = value; }
+
+    /**
+     * <p>The name of the global table.</p>
+     */
+    inline void SetGlobalTableName(Aws::String&& value) { m_globalTableNameHasBeenSet = true; m_globalTableName = std::move(value); }
+
+    /**
+     * <p>The name of the global table.</p>
+     */
+    inline void SetGlobalTableName(const char* value) { m_globalTableNameHasBeenSet = true; m_globalTableName.assign(value); }
+
+    /**
+     * <p>The name of the global table.</p>
+     */
+    inline DescribeGlobalTableRequest& WithGlobalTableName(const Aws::String& value) { SetGlobalTableName(value); return *this;}
+
+    /**
+     * <p>The name of the global table.</p>
+     */
+    inline DescribeGlobalTableRequest& WithGlobalTableName(Aws::String&& value) { SetGlobalTableName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the global table.</p>
+     */
+    inline DescribeGlobalTableRequest& WithGlobalTableName(const char* value) { SetGlobalTableName(value); return *this;}
+
+  private:
+
+    Aws::String m_globalTableName;
+    bool m_globalTableNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DescribeGlobalTableResult.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/model/GlobalTableDescription.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+  class AWS_DYNAMODB_API DescribeGlobalTableResult
+  {
+  public:
+    DescribeGlobalTableResult();
+    DescribeGlobalTableResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DescribeGlobalTableResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Contains the details of the global table.</p>
+     */
+    inline const GlobalTableDescription& GetGlobalTableDescription() const{ return m_globalTableDescription; }
+
+    /**
+     * <p>Contains the details of the global table.</p>
+     */
+    inline void SetGlobalTableDescription(const GlobalTableDescription& value) { m_globalTableDescription = value; }
+
+    /**
+     * <p>Contains the details of the global table.</p>
+     */
+    inline void SetGlobalTableDescription(GlobalTableDescription&& value) { m_globalTableDescription = std::move(value); }
+
+    /**
+     * <p>Contains the details of the global table.</p>
+     */
+    inline DescribeGlobalTableResult& WithGlobalTableDescription(const GlobalTableDescription& value) { SetGlobalTableDescription(value); return *this;}
+
+    /**
+     * <p>Contains the details of the global table.</p>
+     */
+    inline DescribeGlobalTableResult& WithGlobalTableDescription(GlobalTableDescription&& value) { SetGlobalTableDescription(std::move(value)); return *this;}
+
+  private:
+
+    GlobalTableDescription m_globalTableDescription;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DescribeGlobalTableSettingsRequest.h

@@ -0,0 +1,85 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/DynamoDBRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DYNAMODB_API DescribeGlobalTableSettingsRequest : public DynamoDBRequest
+  {
+  public:
+    DescribeGlobalTableSettingsRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DescribeGlobalTableSettings"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the global table to describe.</p>
+     */
+    inline const Aws::String& GetGlobalTableName() const{ return m_globalTableName; }
+
+    /**
+     * <p>The name of the global table to describe.</p>
+     */
+    inline bool GlobalTableNameHasBeenSet() const { return m_globalTableNameHasBeenSet; }
+
+    /**
+     * <p>The name of the global table to describe.</p>
+     */
+    inline void SetGlobalTableName(const Aws::String& value) { m_globalTableNameHasBeenSet = true; m_globalTableName = value; }
+
+    /**
+     * <p>The name of the global table to describe.</p>
+     */
+    inline void SetGlobalTableName(Aws::String&& value) { m_globalTableNameHasBeenSet = true; m_globalTableName = std::move(value); }
+
+    /**
+     * <p>The name of the global table to describe.</p>
+     */
+    inline void SetGlobalTableName(const char* value) { m_globalTableNameHasBeenSet = true; m_globalTableName.assign(value); }
+
+    /**
+     * <p>The name of the global table to describe.</p>
+     */
+    inline DescribeGlobalTableSettingsRequest& WithGlobalTableName(const Aws::String& value) { SetGlobalTableName(value); return *this;}
+
+    /**
+     * <p>The name of the global table to describe.</p>
+     */
+    inline DescribeGlobalTableSettingsRequest& WithGlobalTableName(Aws::String&& value) { SetGlobalTableName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the global table to describe.</p>
+     */
+    inline DescribeGlobalTableSettingsRequest& WithGlobalTableName(const char* value) { SetGlobalTableName(value); return *this;}
+
+  private:
+
+    Aws::String m_globalTableName;
+    bool m_globalTableNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DescribeGlobalTableSettingsResult.h

@@ -0,0 +1,117 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/dynamodb/model/ReplicaSettingsDescription.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+  class AWS_DYNAMODB_API DescribeGlobalTableSettingsResult
+  {
+  public:
+    DescribeGlobalTableSettingsResult();
+    DescribeGlobalTableSettingsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DescribeGlobalTableSettingsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The name of the global table.</p>
+     */
+    inline const Aws::String& GetGlobalTableName() const{ return m_globalTableName; }
+
+    /**
+     * <p>The name of the global table.</p>
+     */
+    inline void SetGlobalTableName(const Aws::String& value) { m_globalTableName = value; }
+
+    /**
+     * <p>The name of the global table.</p>
+     */
+    inline void SetGlobalTableName(Aws::String&& value) { m_globalTableName = std::move(value); }
+
+    /**
+     * <p>The name of the global table.</p>
+     */
+    inline void SetGlobalTableName(const char* value) { m_globalTableName.assign(value); }
+
+    /**
+     * <p>The name of the global table.</p>
+     */
+    inline DescribeGlobalTableSettingsResult& WithGlobalTableName(const Aws::String& value) { SetGlobalTableName(value); return *this;}
+
+    /**
+     * <p>The name of the global table.</p>
+     */
+    inline DescribeGlobalTableSettingsResult& WithGlobalTableName(Aws::String&& value) { SetGlobalTableName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the global table.</p>
+     */
+    inline DescribeGlobalTableSettingsResult& WithGlobalTableName(const char* value) { SetGlobalTableName(value); return *this;}
+
+
+    /**
+     * <p>The Region-specific settings for the global table.</p>
+     */
+    inline const Aws::Vector<ReplicaSettingsDescription>& GetReplicaSettings() const{ return m_replicaSettings; }
+
+    /**
+     * <p>The Region-specific settings for the global table.</p>
+     */
+    inline void SetReplicaSettings(const Aws::Vector<ReplicaSettingsDescription>& value) { m_replicaSettings = value; }
+
+    /**
+     * <p>The Region-specific settings for the global table.</p>
+     */
+    inline void SetReplicaSettings(Aws::Vector<ReplicaSettingsDescription>&& value) { m_replicaSettings = std::move(value); }
+
+    /**
+     * <p>The Region-specific settings for the global table.</p>
+     */
+    inline DescribeGlobalTableSettingsResult& WithReplicaSettings(const Aws::Vector<ReplicaSettingsDescription>& value) { SetReplicaSettings(value); return *this;}
+
+    /**
+     * <p>The Region-specific settings for the global table.</p>
+     */
+    inline DescribeGlobalTableSettingsResult& WithReplicaSettings(Aws::Vector<ReplicaSettingsDescription>&& value) { SetReplicaSettings(std::move(value)); return *this;}
+
+    /**
+     * <p>The Region-specific settings for the global table.</p>
+     */
+    inline DescribeGlobalTableSettingsResult& AddReplicaSettings(const ReplicaSettingsDescription& value) { m_replicaSettings.push_back(value); return *this; }
+
+    /**
+     * <p>The Region-specific settings for the global table.</p>
+     */
+    inline DescribeGlobalTableSettingsResult& AddReplicaSettings(ReplicaSettingsDescription&& value) { m_replicaSettings.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_globalTableName;
+
+    Aws::Vector<ReplicaSettingsDescription> m_replicaSettings;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DescribeLimitsRequest.h

@@ -0,0 +1,42 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/DynamoDBRequest.h>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents the input of a <code>DescribeLimits</code> operation. Has no
+   * content.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeLimitsInput">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API DescribeLimitsRequest : public DynamoDBRequest
+  {
+  public:
+    DescribeLimitsRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DescribeLimits"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DescribeLimitsResult.h

@@ -0,0 +1,133 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+  /**
+   * <p>Represents the output of a <code>DescribeLimits</code>
+   * operation.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeLimitsOutput">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API DescribeLimitsResult
+  {
+  public:
+    DescribeLimitsResult();
+    DescribeLimitsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DescribeLimitsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The maximum total read capacity units that your account allows you to
+     * provision across all of your tables in this Region.</p>
+     */
+    inline long long GetAccountMaxReadCapacityUnits() const{ return m_accountMaxReadCapacityUnits; }
+
+    /**
+     * <p>The maximum total read capacity units that your account allows you to
+     * provision across all of your tables in this Region.</p>
+     */
+    inline void SetAccountMaxReadCapacityUnits(long long value) { m_accountMaxReadCapacityUnits = value; }
+
+    /**
+     * <p>The maximum total read capacity units that your account allows you to
+     * provision across all of your tables in this Region.</p>
+     */
+    inline DescribeLimitsResult& WithAccountMaxReadCapacityUnits(long long value) { SetAccountMaxReadCapacityUnits(value); return *this;}
+
+
+    /**
+     * <p>The maximum total write capacity units that your account allows you to
+     * provision across all of your tables in this Region.</p>
+     */
+    inline long long GetAccountMaxWriteCapacityUnits() const{ return m_accountMaxWriteCapacityUnits; }
+
+    /**
+     * <p>The maximum total write capacity units that your account allows you to
+     * provision across all of your tables in this Region.</p>
+     */
+    inline void SetAccountMaxWriteCapacityUnits(long long value) { m_accountMaxWriteCapacityUnits = value; }
+
+    /**
+     * <p>The maximum total write capacity units that your account allows you to
+     * provision across all of your tables in this Region.</p>
+     */
+    inline DescribeLimitsResult& WithAccountMaxWriteCapacityUnits(long long value) { SetAccountMaxWriteCapacityUnits(value); return *this;}
+
+
+    /**
+     * <p>The maximum read capacity units that your account allows you to provision for
+     * a new table that you are creating in this Region, including the read capacity
+     * units provisioned for its global secondary indexes (GSIs).</p>
+     */
+    inline long long GetTableMaxReadCapacityUnits() const{ return m_tableMaxReadCapacityUnits; }
+
+    /**
+     * <p>The maximum read capacity units that your account allows you to provision for
+     * a new table that you are creating in this Region, including the read capacity
+     * units provisioned for its global secondary indexes (GSIs).</p>
+     */
+    inline void SetTableMaxReadCapacityUnits(long long value) { m_tableMaxReadCapacityUnits = value; }
+
+    /**
+     * <p>The maximum read capacity units that your account allows you to provision for
+     * a new table that you are creating in this Region, including the read capacity
+     * units provisioned for its global secondary indexes (GSIs).</p>
+     */
+    inline DescribeLimitsResult& WithTableMaxReadCapacityUnits(long long value) { SetTableMaxReadCapacityUnits(value); return *this;}
+
+
+    /**
+     * <p>The maximum write capacity units that your account allows you to provision
+     * for a new table that you are creating in this Region, including the write
+     * capacity units provisioned for its global secondary indexes (GSIs).</p>
+     */
+    inline long long GetTableMaxWriteCapacityUnits() const{ return m_tableMaxWriteCapacityUnits; }
+
+    /**
+     * <p>The maximum write capacity units that your account allows you to provision
+     * for a new table that you are creating in this Region, including the write
+     * capacity units provisioned for its global secondary indexes (GSIs).</p>
+     */
+    inline void SetTableMaxWriteCapacityUnits(long long value) { m_tableMaxWriteCapacityUnits = value; }
+
+    /**
+     * <p>The maximum write capacity units that your account allows you to provision
+     * for a new table that you are creating in this Region, including the write
+     * capacity units provisioned for its global secondary indexes (GSIs).</p>
+     */
+    inline DescribeLimitsResult& WithTableMaxWriteCapacityUnits(long long value) { SetTableMaxWriteCapacityUnits(value); return *this;}
+
+  private:
+
+    long long m_accountMaxReadCapacityUnits;
+
+    long long m_accountMaxWriteCapacityUnits;
+
+    long long m_tableMaxReadCapacityUnits;
+
+    long long m_tableMaxWriteCapacityUnits;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DescribeTableReplicaAutoScalingRequest.h

@@ -0,0 +1,85 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/DynamoDBRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DYNAMODB_API DescribeTableReplicaAutoScalingRequest : public DynamoDBRequest
+  {
+  public:
+    DescribeTableReplicaAutoScalingRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DescribeTableReplicaAutoScaling"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the table.</p>
+     */
+    inline const Aws::String& GetTableName() const{ return m_tableName; }
+
+    /**
+     * <p>The name of the table.</p>
+     */
+    inline bool TableNameHasBeenSet() const { return m_tableNameHasBeenSet; }
+
+    /**
+     * <p>The name of the table.</p>
+     */
+    inline void SetTableName(const Aws::String& value) { m_tableNameHasBeenSet = true; m_tableName = value; }
+
+    /**
+     * <p>The name of the table.</p>
+     */
+    inline void SetTableName(Aws::String&& value) { m_tableNameHasBeenSet = true; m_tableName = std::move(value); }
+
+    /**
+     * <p>The name of the table.</p>
+     */
+    inline void SetTableName(const char* value) { m_tableNameHasBeenSet = true; m_tableName.assign(value); }
+
+    /**
+     * <p>The name of the table.</p>
+     */
+    inline DescribeTableReplicaAutoScalingRequest& WithTableName(const Aws::String& value) { SetTableName(value); return *this;}
+
+    /**
+     * <p>The name of the table.</p>
+     */
+    inline DescribeTableReplicaAutoScalingRequest& WithTableName(Aws::String&& value) { SetTableName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the table.</p>
+     */
+    inline DescribeTableReplicaAutoScalingRequest& WithTableName(const char* value) { SetTableName(value); return *this;}
+
+  private:
+
+    Aws::String m_tableName;
+    bool m_tableNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DescribeTableReplicaAutoScalingResult.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/model/TableAutoScalingDescription.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+  class AWS_DYNAMODB_API DescribeTableReplicaAutoScalingResult
+  {
+  public:
+    DescribeTableReplicaAutoScalingResult();
+    DescribeTableReplicaAutoScalingResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DescribeTableReplicaAutoScalingResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Represents the auto scaling properties of the table.</p>
+     */
+    inline const TableAutoScalingDescription& GetTableAutoScalingDescription() const{ return m_tableAutoScalingDescription; }
+
+    /**
+     * <p>Represents the auto scaling properties of the table.</p>
+     */
+    inline void SetTableAutoScalingDescription(const TableAutoScalingDescription& value) { m_tableAutoScalingDescription = value; }
+
+    /**
+     * <p>Represents the auto scaling properties of the table.</p>
+     */
+    inline void SetTableAutoScalingDescription(TableAutoScalingDescription&& value) { m_tableAutoScalingDescription = std::move(value); }
+
+    /**
+     * <p>Represents the auto scaling properties of the table.</p>
+     */
+    inline DescribeTableReplicaAutoScalingResult& WithTableAutoScalingDescription(const TableAutoScalingDescription& value) { SetTableAutoScalingDescription(value); return *this;}
+
+    /**
+     * <p>Represents the auto scaling properties of the table.</p>
+     */
+    inline DescribeTableReplicaAutoScalingResult& WithTableAutoScalingDescription(TableAutoScalingDescription&& value) { SetTableAutoScalingDescription(std::move(value)); return *this;}
+
+  private:
+
+    TableAutoScalingDescription m_tableAutoScalingDescription;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DescribeTableRequest.h

@@ -0,0 +1,89 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/DynamoDBRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents the input of a <code>DescribeTable</code> operation.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeTableInput">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API DescribeTableRequest : public DynamoDBRequest
+  {
+  public:
+    DescribeTableRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DescribeTable"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the table to describe.</p>
+     */
+    inline const Aws::String& GetTableName() const{ return m_tableName; }
+
+    /**
+     * <p>The name of the table to describe.</p>
+     */
+    inline bool TableNameHasBeenSet() const { return m_tableNameHasBeenSet; }
+
+    /**
+     * <p>The name of the table to describe.</p>
+     */
+    inline void SetTableName(const Aws::String& value) { m_tableNameHasBeenSet = true; m_tableName = value; }
+
+    /**
+     * <p>The name of the table to describe.</p>
+     */
+    inline void SetTableName(Aws::String&& value) { m_tableNameHasBeenSet = true; m_tableName = std::move(value); }
+
+    /**
+     * <p>The name of the table to describe.</p>
+     */
+    inline void SetTableName(const char* value) { m_tableNameHasBeenSet = true; m_tableName.assign(value); }
+
+    /**
+     * <p>The name of the table to describe.</p>
+     */
+    inline DescribeTableRequest& WithTableName(const Aws::String& value) { SetTableName(value); return *this;}
+
+    /**
+     * <p>The name of the table to describe.</p>
+     */
+    inline DescribeTableRequest& WithTableName(Aws::String&& value) { SetTableName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the table to describe.</p>
+     */
+    inline DescribeTableRequest& WithTableName(const char* value) { SetTableName(value); return *this;}
+
+  private:
+
+    Aws::String m_tableName;
+    bool m_tableNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DescribeTableResult.h

@@ -0,0 +1,73 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/model/TableDescription.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+  /**
+   * <p>Represents the output of a <code>DescribeTable</code>
+   * operation.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeTableOutput">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API DescribeTableResult
+  {
+  public:
+    DescribeTableResult();
+    DescribeTableResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DescribeTableResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The properties of the table.</p>
+     */
+    inline const TableDescription& GetTable() const{ return m_table; }
+
+    /**
+     * <p>The properties of the table.</p>
+     */
+    inline void SetTable(const TableDescription& value) { m_table = value; }
+
+    /**
+     * <p>The properties of the table.</p>
+     */
+    inline void SetTable(TableDescription&& value) { m_table = std::move(value); }
+
+    /**
+     * <p>The properties of the table.</p>
+     */
+    inline DescribeTableResult& WithTable(const TableDescription& value) { SetTable(value); return *this;}
+
+    /**
+     * <p>The properties of the table.</p>
+     */
+    inline DescribeTableResult& WithTable(TableDescription&& value) { SetTable(std::move(value)); return *this;}
+
+  private:
+
+    TableDescription m_table;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DescribeTimeToLiveRequest.h

@@ -0,0 +1,85 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/DynamoDBRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DYNAMODB_API DescribeTimeToLiveRequest : public DynamoDBRequest
+  {
+  public:
+    DescribeTimeToLiveRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DescribeTimeToLive"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the table to be described.</p>
+     */
+    inline const Aws::String& GetTableName() const{ return m_tableName; }
+
+    /**
+     * <p>The name of the table to be described.</p>
+     */
+    inline bool TableNameHasBeenSet() const { return m_tableNameHasBeenSet; }
+
+    /**
+     * <p>The name of the table to be described.</p>
+     */
+    inline void SetTableName(const Aws::String& value) { m_tableNameHasBeenSet = true; m_tableName = value; }
+
+    /**
+     * <p>The name of the table to be described.</p>
+     */
+    inline void SetTableName(Aws::String&& value) { m_tableNameHasBeenSet = true; m_tableName = std::move(value); }
+
+    /**
+     * <p>The name of the table to be described.</p>
+     */
+    inline void SetTableName(const char* value) { m_tableNameHasBeenSet = true; m_tableName.assign(value); }
+
+    /**
+     * <p>The name of the table to be described.</p>
+     */
+    inline DescribeTimeToLiveRequest& WithTableName(const Aws::String& value) { SetTableName(value); return *this;}
+
+    /**
+     * <p>The name of the table to be described.</p>
+     */
+    inline DescribeTimeToLiveRequest& WithTableName(Aws::String&& value) { SetTableName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the table to be described.</p>
+     */
+    inline DescribeTimeToLiveRequest& WithTableName(const char* value) { SetTableName(value); return *this;}
+
+  private:
+
+    Aws::String m_tableName;
+    bool m_tableNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/DescribeTimeToLiveResult.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/model/TimeToLiveDescription.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+  class AWS_DYNAMODB_API DescribeTimeToLiveResult
+  {
+  public:
+    DescribeTimeToLiveResult();
+    DescribeTimeToLiveResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DescribeTimeToLiveResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p/>
+     */
+    inline const TimeToLiveDescription& GetTimeToLiveDescription() const{ return m_timeToLiveDescription; }
+
+    /**
+     * <p/>
+     */
+    inline void SetTimeToLiveDescription(const TimeToLiveDescription& value) { m_timeToLiveDescription = value; }
+
+    /**
+     * <p/>
+     */
+    inline void SetTimeToLiveDescription(TimeToLiveDescription&& value) { m_timeToLiveDescription = std::move(value); }
+
+    /**
+     * <p/>
+     */
+    inline DescribeTimeToLiveResult& WithTimeToLiveDescription(const TimeToLiveDescription& value) { SetTimeToLiveDescription(value); return *this;}
+
+    /**
+     * <p/>
+     */
+    inline DescribeTimeToLiveResult& WithTimeToLiveDescription(TimeToLiveDescription&& value) { SetTimeToLiveDescription(std::move(value)); return *this;}
+
+  private:
+
+    TimeToLiveDescription m_timeToLiveDescription;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/Endpoint.h

@@ -0,0 +1,112 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>An endpoint information details.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/Endpoint">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API Endpoint
+  {
+  public:
+    Endpoint();
+    Endpoint(Aws::Utils::Json::JsonView jsonValue);
+    Endpoint& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>IP address of the endpoint.</p>
+     */
+    inline const Aws::String& GetAddress() const{ return m_address; }
+
+    /**
+     * <p>IP address of the endpoint.</p>
+     */
+    inline bool AddressHasBeenSet() const { return m_addressHasBeenSet; }
+
+    /**
+     * <p>IP address of the endpoint.</p>
+     */
+    inline void SetAddress(const Aws::String& value) { m_addressHasBeenSet = true; m_address = value; }
+
+    /**
+     * <p>IP address of the endpoint.</p>
+     */
+    inline void SetAddress(Aws::String&& value) { m_addressHasBeenSet = true; m_address = std::move(value); }
+
+    /**
+     * <p>IP address of the endpoint.</p>
+     */
+    inline void SetAddress(const char* value) { m_addressHasBeenSet = true; m_address.assign(value); }
+
+    /**
+     * <p>IP address of the endpoint.</p>
+     */
+    inline Endpoint& WithAddress(const Aws::String& value) { SetAddress(value); return *this;}
+
+    /**
+     * <p>IP address of the endpoint.</p>
+     */
+    inline Endpoint& WithAddress(Aws::String&& value) { SetAddress(std::move(value)); return *this;}
+
+    /**
+     * <p>IP address of the endpoint.</p>
+     */
+    inline Endpoint& WithAddress(const char* value) { SetAddress(value); return *this;}
+
+
+    /**
+     * <p>Endpoint cache time to live (TTL) value.</p>
+     */
+    inline long long GetCachePeriodInMinutes() const{ return m_cachePeriodInMinutes; }
+
+    /**
+     * <p>Endpoint cache time to live (TTL) value.</p>
+     */
+    inline bool CachePeriodInMinutesHasBeenSet() const { return m_cachePeriodInMinutesHasBeenSet; }
+
+    /**
+     * <p>Endpoint cache time to live (TTL) value.</p>
+     */
+    inline void SetCachePeriodInMinutes(long long value) { m_cachePeriodInMinutesHasBeenSet = true; m_cachePeriodInMinutes = value; }
+
+    /**
+     * <p>Endpoint cache time to live (TTL) value.</p>
+     */
+    inline Endpoint& WithCachePeriodInMinutes(long long value) { SetCachePeriodInMinutes(value); return *this;}
+
+  private:
+
+    Aws::String m_address;
+    bool m_addressHasBeenSet;
+
+    long long m_cachePeriodInMinutes;
+    bool m_cachePeriodInMinutesHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/FailureException.h

@@ -0,0 +1,133 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents a failure a contributor insights operation.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/FailureException">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API FailureException
+  {
+  public:
+    FailureException();
+    FailureException(Aws::Utils::Json::JsonView jsonValue);
+    FailureException& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Exception name.</p>
+     */
+    inline const Aws::String& GetExceptionName() const{ return m_exceptionName; }
+
+    /**
+     * <p>Exception name.</p>
+     */
+    inline bool ExceptionNameHasBeenSet() const { return m_exceptionNameHasBeenSet; }
+
+    /**
+     * <p>Exception name.</p>
+     */
+    inline void SetExceptionName(const Aws::String& value) { m_exceptionNameHasBeenSet = true; m_exceptionName = value; }
+
+    /**
+     * <p>Exception name.</p>
+     */
+    inline void SetExceptionName(Aws::String&& value) { m_exceptionNameHasBeenSet = true; m_exceptionName = std::move(value); }
+
+    /**
+     * <p>Exception name.</p>
+     */
+    inline void SetExceptionName(const char* value) { m_exceptionNameHasBeenSet = true; m_exceptionName.assign(value); }
+
+    /**
+     * <p>Exception name.</p>
+     */
+    inline FailureException& WithExceptionName(const Aws::String& value) { SetExceptionName(value); return *this;}
+
+    /**
+     * <p>Exception name.</p>
+     */
+    inline FailureException& WithExceptionName(Aws::String&& value) { SetExceptionName(std::move(value)); return *this;}
+
+    /**
+     * <p>Exception name.</p>
+     */
+    inline FailureException& WithExceptionName(const char* value) { SetExceptionName(value); return *this;}
+
+
+    /**
+     * <p>Description of the failure.</p>
+     */
+    inline const Aws::String& GetExceptionDescription() const{ return m_exceptionDescription; }
+
+    /**
+     * <p>Description of the failure.</p>
+     */
+    inline bool ExceptionDescriptionHasBeenSet() const { return m_exceptionDescriptionHasBeenSet; }
+
+    /**
+     * <p>Description of the failure.</p>
+     */
+    inline void SetExceptionDescription(const Aws::String& value) { m_exceptionDescriptionHasBeenSet = true; m_exceptionDescription = value; }
+
+    /**
+     * <p>Description of the failure.</p>
+     */
+    inline void SetExceptionDescription(Aws::String&& value) { m_exceptionDescriptionHasBeenSet = true; m_exceptionDescription = std::move(value); }
+
+    /**
+     * <p>Description of the failure.</p>
+     */
+    inline void SetExceptionDescription(const char* value) { m_exceptionDescriptionHasBeenSet = true; m_exceptionDescription.assign(value); }
+
+    /**
+     * <p>Description of the failure.</p>
+     */
+    inline FailureException& WithExceptionDescription(const Aws::String& value) { SetExceptionDescription(value); return *this;}
+
+    /**
+     * <p>Description of the failure.</p>
+     */
+    inline FailureException& WithExceptionDescription(Aws::String&& value) { SetExceptionDescription(std::move(value)); return *this;}
+
+    /**
+     * <p>Description of the failure.</p>
+     */
+    inline FailureException& WithExceptionDescription(const char* value) { SetExceptionDescription(value); return *this;}
+
+  private:
+
+    Aws::String m_exceptionName;
+    bool m_exceptionNameHasBeenSet;
+
+    Aws::String m_exceptionDescription;
+    bool m_exceptionDescriptionHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/Get.h

@@ -0,0 +1,325 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/dynamodb/model/AttributeValue.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Specifies an item and related attribute values to retrieve in a
+   * <code>TransactGetItem</code> object.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/Get">AWS API
+   * Reference</a></p>
+   */
+  class AWS_DYNAMODB_API Get
+  {
+  public:
+    Get();
+    Get(Aws::Utils::Json::JsonView jsonValue);
+    Get& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects that
+     * specifies the primary key of the item to retrieve.</p>
+     */
+    inline const Aws::Map<Aws::String, AttributeValue>& GetKey() const{ return m_key; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects that
+     * specifies the primary key of the item to retrieve.</p>
+     */
+    inline bool KeyHasBeenSet() const { return m_keyHasBeenSet; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects that
+     * specifies the primary key of the item to retrieve.</p>
+     */
+    inline void SetKey(const Aws::Map<Aws::String, AttributeValue>& value) { m_keyHasBeenSet = true; m_key = value; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects that
+     * specifies the primary key of the item to retrieve.</p>
+     */
+    inline void SetKey(Aws::Map<Aws::String, AttributeValue>&& value) { m_keyHasBeenSet = true; m_key = std::move(value); }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects that
+     * specifies the primary key of the item to retrieve.</p>
+     */
+    inline Get& WithKey(const Aws::Map<Aws::String, AttributeValue>& value) { SetKey(value); return *this;}
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects that
+     * specifies the primary key of the item to retrieve.</p>
+     */
+    inline Get& WithKey(Aws::Map<Aws::String, AttributeValue>&& value) { SetKey(std::move(value)); return *this;}
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects that
+     * specifies the primary key of the item to retrieve.</p>
+     */
+    inline Get& AddKey(const Aws::String& key, const AttributeValue& value) { m_keyHasBeenSet = true; m_key.emplace(key, value); return *this; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects that
+     * specifies the primary key of the item to retrieve.</p>
+     */
+    inline Get& AddKey(Aws::String&& key, const AttributeValue& value) { m_keyHasBeenSet = true; m_key.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects that
+     * specifies the primary key of the item to retrieve.</p>
+     */
+    inline Get& AddKey(const Aws::String& key, AttributeValue&& value) { m_keyHasBeenSet = true; m_key.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects that
+     * specifies the primary key of the item to retrieve.</p>
+     */
+    inline Get& AddKey(Aws::String&& key, AttributeValue&& value) { m_keyHasBeenSet = true; m_key.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects that
+     * specifies the primary key of the item to retrieve.</p>
+     */
+    inline Get& AddKey(const char* key, AttributeValue&& value) { m_keyHasBeenSet = true; m_key.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects that
+     * specifies the primary key of the item to retrieve.</p>
+     */
+    inline Get& AddKey(const char* key, const AttributeValue& value) { m_keyHasBeenSet = true; m_key.emplace(key, value); return *this; }
+
+
+    /**
+     * <p>The name of the table from which to retrieve the specified item.</p>
+     */
+    inline const Aws::String& GetTableName() const{ return m_tableName; }
+
+    /**
+     * <p>The name of the table from which to retrieve the specified item.</p>
+     */
+    inline bool TableNameHasBeenSet() const { return m_tableNameHasBeenSet; }
+
+    /**
+     * <p>The name of the table from which to retrieve the specified item.</p>
+     */
+    inline void SetTableName(const Aws::String& value) { m_tableNameHasBeenSet = true; m_tableName = value; }
+
+    /**
+     * <p>The name of the table from which to retrieve the specified item.</p>
+     */
+    inline void SetTableName(Aws::String&& value) { m_tableNameHasBeenSet = true; m_tableName = std::move(value); }
+
+    /**
+     * <p>The name of the table from which to retrieve the specified item.</p>
+     */
+    inline void SetTableName(const char* value) { m_tableNameHasBeenSet = true; m_tableName.assign(value); }
+
+    /**
+     * <p>The name of the table from which to retrieve the specified item.</p>
+     */
+    inline Get& WithTableName(const Aws::String& value) { SetTableName(value); return *this;}
+
+    /**
+     * <p>The name of the table from which to retrieve the specified item.</p>
+     */
+    inline Get& WithTableName(Aws::String&& value) { SetTableName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the table from which to retrieve the specified item.</p>
+     */
+    inline Get& WithTableName(const char* value) { SetTableName(value); return *this;}
+
+
+    /**
+     * <p>A string that identifies one or more attributes of the specified item to
+     * retrieve from the table. The attributes in the expression must be separated by
+     * commas. If no attribute names are specified, then all attributes of the
+     * specified item are returned. If any of the requested attributes are not found,
+     * they do not appear in the result.</p>
+     */
+    inline const Aws::String& GetProjectionExpression() const{ return m_projectionExpression; }
+
+    /**
+     * <p>A string that identifies one or more attributes of the specified item to
+     * retrieve from the table. The attributes in the expression must be separated by
+     * commas. If no attribute names are specified, then all attributes of the
+     * specified item are returned. If any of the requested attributes are not found,
+     * they do not appear in the result.</p>
+     */
+    inline bool ProjectionExpressionHasBeenSet() const { return m_projectionExpressionHasBeenSet; }
+
+    /**
+     * <p>A string that identifies one or more attributes of the specified item to
+     * retrieve from the table. The attributes in the expression must be separated by
+     * commas. If no attribute names are specified, then all attributes of the
+     * specified item are returned. If any of the requested attributes are not found,
+     * they do not appear in the result.</p>
+     */
+    inline void SetProjectionExpression(const Aws::String& value) { m_projectionExpressionHasBeenSet = true; m_projectionExpression = value; }
+
+    /**
+     * <p>A string that identifies one or more attributes of the specified item to
+     * retrieve from the table. The attributes in the expression must be separated by
+     * commas. If no attribute names are specified, then all attributes of the
+     * specified item are returned. If any of the requested attributes are not found,
+     * they do not appear in the result.</p>
+     */
+    inline void SetProjectionExpression(Aws::String&& value) { m_projectionExpressionHasBeenSet = true; m_projectionExpression = std::move(value); }
+
+    /**
+     * <p>A string that identifies one or more attributes of the specified item to
+     * retrieve from the table. The attributes in the expression must be separated by
+     * commas. If no attribute names are specified, then all attributes of the
+     * specified item are returned. If any of the requested attributes are not found,
+     * they do not appear in the result.</p>
+     */
+    inline void SetProjectionExpression(const char* value) { m_projectionExpressionHasBeenSet = true; m_projectionExpression.assign(value); }
+
+    /**
+     * <p>A string that identifies one or more attributes of the specified item to
+     * retrieve from the table. The attributes in the expression must be separated by
+     * commas. If no attribute names are specified, then all attributes of the
+     * specified item are returned. If any of the requested attributes are not found,
+     * they do not appear in the result.</p>
+     */
+    inline Get& WithProjectionExpression(const Aws::String& value) { SetProjectionExpression(value); return *this;}
+
+    /**
+     * <p>A string that identifies one or more attributes of the specified item to
+     * retrieve from the table. The attributes in the expression must be separated by
+     * commas. If no attribute names are specified, then all attributes of the
+     * specified item are returned. If any of the requested attributes are not found,
+     * they do not appear in the result.</p>
+     */
+    inline Get& WithProjectionExpression(Aws::String&& value) { SetProjectionExpression(std::move(value)); return *this;}
+
+    /**
+     * <p>A string that identifies one or more attributes of the specified item to
+     * retrieve from the table. The attributes in the expression must be separated by
+     * commas. If no attribute names are specified, then all attributes of the
+     * specified item are returned. If any of the requested attributes are not found,
+     * they do not appear in the result.</p>
+     */
+    inline Get& WithProjectionExpression(const char* value) { SetProjectionExpression(value); return *this;}
+
+
+    /**
+     * <p>One or more substitution tokens for attribute names in the
+     * ProjectionExpression parameter.</p>
+     */
+    inline const Aws::Map<Aws::String, Aws::String>& GetExpressionAttributeNames() const{ return m_expressionAttributeNames; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in the
+     * ProjectionExpression parameter.</p>
+     */
+    inline bool ExpressionAttributeNamesHasBeenSet() const { return m_expressionAttributeNamesHasBeenSet; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in the
+     * ProjectionExpression parameter.</p>
+     */
+    inline void SetExpressionAttributeNames(const Aws::Map<Aws::String, Aws::String>& value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames = value; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in the
+     * ProjectionExpression parameter.</p>
+     */
+    inline void SetExpressionAttributeNames(Aws::Map<Aws::String, Aws::String>&& value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames = std::move(value); }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in the
+     * ProjectionExpression parameter.</p>
+     */
+    inline Get& WithExpressionAttributeNames(const Aws::Map<Aws::String, Aws::String>& value) { SetExpressionAttributeNames(value); return *this;}
+
+    /**
+     * <p>One or more substitution tokens for attribute names in the
+     * ProjectionExpression parameter.</p>
+     */
+    inline Get& WithExpressionAttributeNames(Aws::Map<Aws::String, Aws::String>&& value) { SetExpressionAttributeNames(std::move(value)); return *this;}
+
+    /**
+     * <p>One or more substitution tokens for attribute names in the
+     * ProjectionExpression parameter.</p>
+     */
+    inline Get& AddExpressionAttributeNames(const Aws::String& key, const Aws::String& value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames.emplace(key, value); return *this; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in the
+     * ProjectionExpression parameter.</p>
+     */
+    inline Get& AddExpressionAttributeNames(Aws::String&& key, const Aws::String& value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in the
+     * ProjectionExpression parameter.</p>
+     */
+    inline Get& AddExpressionAttributeNames(const Aws::String& key, Aws::String&& value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in the
+     * ProjectionExpression parameter.</p>
+     */
+    inline Get& AddExpressionAttributeNames(Aws::String&& key, Aws::String&& value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in the
+     * ProjectionExpression parameter.</p>
+     */
+    inline Get& AddExpressionAttributeNames(const char* key, Aws::String&& value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in the
+     * ProjectionExpression parameter.</p>
+     */
+    inline Get& AddExpressionAttributeNames(Aws::String&& key, const char* value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in the
+     * ProjectionExpression parameter.</p>
+     */
+    inline Get& AddExpressionAttributeNames(const char* key, const char* value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames.emplace(key, value); return *this; }
+
+  private:
+
+    Aws::Map<Aws::String, AttributeValue> m_key;
+    bool m_keyHasBeenSet;
+
+    Aws::String m_tableName;
+    bool m_tableNameHasBeenSet;
+
+    Aws::String m_projectionExpression;
+    bool m_projectionExpressionHasBeenSet;
+
+    Aws::Map<Aws::String, Aws::String> m_expressionAttributeNames;
+    bool m_expressionAttributeNamesHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/GetItemRequest.h

@@ -0,0 +1,790 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/DynamoDBRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/dynamodb/model/ReturnConsumedCapacity.h>
+#include <aws/dynamodb/model/AttributeValue.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents the input of a <code>GetItem</code> operation.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/GetItemInput">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API GetItemRequest : public DynamoDBRequest
+  {
+  public:
+    GetItemRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "GetItem"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the table containing the requested item.</p>
+     */
+    inline const Aws::String& GetTableName() const{ return m_tableName; }
+
+    /**
+     * <p>The name of the table containing the requested item.</p>
+     */
+    inline bool TableNameHasBeenSet() const { return m_tableNameHasBeenSet; }
+
+    /**
+     * <p>The name of the table containing the requested item.</p>
+     */
+    inline void SetTableName(const Aws::String& value) { m_tableNameHasBeenSet = true; m_tableName = value; }
+
+    /**
+     * <p>The name of the table containing the requested item.</p>
+     */
+    inline void SetTableName(Aws::String&& value) { m_tableNameHasBeenSet = true; m_tableName = std::move(value); }
+
+    /**
+     * <p>The name of the table containing the requested item.</p>
+     */
+    inline void SetTableName(const char* value) { m_tableNameHasBeenSet = true; m_tableName.assign(value); }
+
+    /**
+     * <p>The name of the table containing the requested item.</p>
+     */
+    inline GetItemRequest& WithTableName(const Aws::String& value) { SetTableName(value); return *this;}
+
+    /**
+     * <p>The name of the table containing the requested item.</p>
+     */
+    inline GetItemRequest& WithTableName(Aws::String&& value) { SetTableName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the table containing the requested item.</p>
+     */
+    inline GetItemRequest& WithTableName(const char* value) { SetTableName(value); return *this;}
+
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, representing
+     * the primary key of the item to retrieve.</p> <p>For the primary key, you must
+     * provide all of the attributes. For example, with a simple primary key, you only
+     * need to provide a value for the partition key. For a composite primary key, you
+     * must provide values for both the partition key and the sort key.</p>
+     */
+    inline const Aws::Map<Aws::String, AttributeValue>& GetKey() const{ return m_key; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, representing
+     * the primary key of the item to retrieve.</p> <p>For the primary key, you must
+     * provide all of the attributes. For example, with a simple primary key, you only
+     * need to provide a value for the partition key. For a composite primary key, you
+     * must provide values for both the partition key and the sort key.</p>
+     */
+    inline bool KeyHasBeenSet() const { return m_keyHasBeenSet; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, representing
+     * the primary key of the item to retrieve.</p> <p>For the primary key, you must
+     * provide all of the attributes. For example, with a simple primary key, you only
+     * need to provide a value for the partition key. For a composite primary key, you
+     * must provide values for both the partition key and the sort key.</p>
+     */
+    inline void SetKey(const Aws::Map<Aws::String, AttributeValue>& value) { m_keyHasBeenSet = true; m_key = value; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, representing
+     * the primary key of the item to retrieve.</p> <p>For the primary key, you must
+     * provide all of the attributes. For example, with a simple primary key, you only
+     * need to provide a value for the partition key. For a composite primary key, you
+     * must provide values for both the partition key and the sort key.</p>
+     */
+    inline void SetKey(Aws::Map<Aws::String, AttributeValue>&& value) { m_keyHasBeenSet = true; m_key = std::move(value); }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, representing
+     * the primary key of the item to retrieve.</p> <p>For the primary key, you must
+     * provide all of the attributes. For example, with a simple primary key, you only
+     * need to provide a value for the partition key. For a composite primary key, you
+     * must provide values for both the partition key and the sort key.</p>
+     */
+    inline GetItemRequest& WithKey(const Aws::Map<Aws::String, AttributeValue>& value) { SetKey(value); return *this;}
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, representing
+     * the primary key of the item to retrieve.</p> <p>For the primary key, you must
+     * provide all of the attributes. For example, with a simple primary key, you only
+     * need to provide a value for the partition key. For a composite primary key, you
+     * must provide values for both the partition key and the sort key.</p>
+     */
+    inline GetItemRequest& WithKey(Aws::Map<Aws::String, AttributeValue>&& value) { SetKey(std::move(value)); return *this;}
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, representing
+     * the primary key of the item to retrieve.</p> <p>For the primary key, you must
+     * provide all of the attributes. For example, with a simple primary key, you only
+     * need to provide a value for the partition key. For a composite primary key, you
+     * must provide values for both the partition key and the sort key.</p>
+     */
+    inline GetItemRequest& AddKey(const Aws::String& key, const AttributeValue& value) { m_keyHasBeenSet = true; m_key.emplace(key, value); return *this; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, representing
+     * the primary key of the item to retrieve.</p> <p>For the primary key, you must
+     * provide all of the attributes. For example, with a simple primary key, you only
+     * need to provide a value for the partition key. For a composite primary key, you
+     * must provide values for both the partition key and the sort key.</p>
+     */
+    inline GetItemRequest& AddKey(Aws::String&& key, const AttributeValue& value) { m_keyHasBeenSet = true; m_key.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, representing
+     * the primary key of the item to retrieve.</p> <p>For the primary key, you must
+     * provide all of the attributes. For example, with a simple primary key, you only
+     * need to provide a value for the partition key. For a composite primary key, you
+     * must provide values for both the partition key and the sort key.</p>
+     */
+    inline GetItemRequest& AddKey(const Aws::String& key, AttributeValue&& value) { m_keyHasBeenSet = true; m_key.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, representing
+     * the primary key of the item to retrieve.</p> <p>For the primary key, you must
+     * provide all of the attributes. For example, with a simple primary key, you only
+     * need to provide a value for the partition key. For a composite primary key, you
+     * must provide values for both the partition key and the sort key.</p>
+     */
+    inline GetItemRequest& AddKey(Aws::String&& key, AttributeValue&& value) { m_keyHasBeenSet = true; m_key.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, representing
+     * the primary key of the item to retrieve.</p> <p>For the primary key, you must
+     * provide all of the attributes. For example, with a simple primary key, you only
+     * need to provide a value for the partition key. For a composite primary key, you
+     * must provide values for both the partition key and the sort key.</p>
+     */
+    inline GetItemRequest& AddKey(const char* key, AttributeValue&& value) { m_keyHasBeenSet = true; m_key.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, representing
+     * the primary key of the item to retrieve.</p> <p>For the primary key, you must
+     * provide all of the attributes. For example, with a simple primary key, you only
+     * need to provide a value for the partition key. For a composite primary key, you
+     * must provide values for both the partition key and the sort key.</p>
+     */
+    inline GetItemRequest& AddKey(const char* key, const AttributeValue& value) { m_keyHasBeenSet = true; m_key.emplace(key, value); return *this; }
+
+
+    /**
+     * <p>This is a legacy parameter. Use <code>ProjectionExpression</code> instead.
+     * For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html">AttributesToGet</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetAttributesToGet() const{ return m_attributesToGet; }
+
+    /**
+     * <p>This is a legacy parameter. Use <code>ProjectionExpression</code> instead.
+     * For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html">AttributesToGet</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline bool AttributesToGetHasBeenSet() const { return m_attributesToGetHasBeenSet; }
+
+    /**
+     * <p>This is a legacy parameter. Use <code>ProjectionExpression</code> instead.
+     * For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html">AttributesToGet</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline void SetAttributesToGet(const Aws::Vector<Aws::String>& value) { m_attributesToGetHasBeenSet = true; m_attributesToGet = value; }
+
+    /**
+     * <p>This is a legacy parameter. Use <code>ProjectionExpression</code> instead.
+     * For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html">AttributesToGet</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline void SetAttributesToGet(Aws::Vector<Aws::String>&& value) { m_attributesToGetHasBeenSet = true; m_attributesToGet = std::move(value); }
+
+    /**
+     * <p>This is a legacy parameter. Use <code>ProjectionExpression</code> instead.
+     * For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html">AttributesToGet</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline GetItemRequest& WithAttributesToGet(const Aws::Vector<Aws::String>& value) { SetAttributesToGet(value); return *this;}
+
+    /**
+     * <p>This is a legacy parameter. Use <code>ProjectionExpression</code> instead.
+     * For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html">AttributesToGet</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline GetItemRequest& WithAttributesToGet(Aws::Vector<Aws::String>&& value) { SetAttributesToGet(std::move(value)); return *this;}
+
+    /**
+     * <p>This is a legacy parameter. Use <code>ProjectionExpression</code> instead.
+     * For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html">AttributesToGet</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline GetItemRequest& AddAttributesToGet(const Aws::String& value) { m_attributesToGetHasBeenSet = true; m_attributesToGet.push_back(value); return *this; }
+
+    /**
+     * <p>This is a legacy parameter. Use <code>ProjectionExpression</code> instead.
+     * For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html">AttributesToGet</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline GetItemRequest& AddAttributesToGet(Aws::String&& value) { m_attributesToGetHasBeenSet = true; m_attributesToGet.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>This is a legacy parameter. Use <code>ProjectionExpression</code> instead.
+     * For more information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html">AttributesToGet</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline GetItemRequest& AddAttributesToGet(const char* value) { m_attributesToGetHasBeenSet = true; m_attributesToGet.push_back(value); return *this; }
+
+
+    /**
+     * <p>Determines the read consistency model: If set to <code>true</code>, then the
+     * operation uses strongly consistent reads; otherwise, the operation uses
+     * eventually consistent reads.</p>
+     */
+    inline bool GetConsistentRead() const{ return m_consistentRead; }
+
+    /**
+     * <p>Determines the read consistency model: If set to <code>true</code>, then the
+     * operation uses strongly consistent reads; otherwise, the operation uses
+     * eventually consistent reads.</p>
+     */
+    inline bool ConsistentReadHasBeenSet() const { return m_consistentReadHasBeenSet; }
+
+    /**
+     * <p>Determines the read consistency model: If set to <code>true</code>, then the
+     * operation uses strongly consistent reads; otherwise, the operation uses
+     * eventually consistent reads.</p>
+     */
+    inline void SetConsistentRead(bool value) { m_consistentReadHasBeenSet = true; m_consistentRead = value; }
+
+    /**
+     * <p>Determines the read consistency model: If set to <code>true</code>, then the
+     * operation uses strongly consistent reads; otherwise, the operation uses
+     * eventually consistent reads.</p>
+     */
+    inline GetItemRequest& WithConsistentRead(bool value) { SetConsistentRead(value); return *this;}
+
+
+    
+    inline const ReturnConsumedCapacity& GetReturnConsumedCapacity() const{ return m_returnConsumedCapacity; }
+
+    
+    inline bool ReturnConsumedCapacityHasBeenSet() const { return m_returnConsumedCapacityHasBeenSet; }
+
+    
+    inline void SetReturnConsumedCapacity(const ReturnConsumedCapacity& value) { m_returnConsumedCapacityHasBeenSet = true; m_returnConsumedCapacity = value; }
+
+    
+    inline void SetReturnConsumedCapacity(ReturnConsumedCapacity&& value) { m_returnConsumedCapacityHasBeenSet = true; m_returnConsumedCapacity = std::move(value); }
+
+    
+    inline GetItemRequest& WithReturnConsumedCapacity(const ReturnConsumedCapacity& value) { SetReturnConsumedCapacity(value); return *this;}
+
+    
+    inline GetItemRequest& WithReturnConsumedCapacity(ReturnConsumedCapacity&& value) { SetReturnConsumedCapacity(std::move(value)); return *this;}
+
+
+    /**
+     * <p>A string that identifies one or more attributes to retrieve from the table.
+     * These attributes can include scalars, sets, or elements of a JSON document. The
+     * attributes in the expression must be separated by commas.</p> <p>If no attribute
+     * names are specified, then all attributes are returned. If any of the requested
+     * attributes are not found, they do not appear in the result.</p> <p>For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Specifying
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline const Aws::String& GetProjectionExpression() const{ return m_projectionExpression; }
+
+    /**
+     * <p>A string that identifies one or more attributes to retrieve from the table.
+     * These attributes can include scalars, sets, or elements of a JSON document. The
+     * attributes in the expression must be separated by commas.</p> <p>If no attribute
+     * names are specified, then all attributes are returned. If any of the requested
+     * attributes are not found, they do not appear in the result.</p> <p>For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Specifying
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline bool ProjectionExpressionHasBeenSet() const { return m_projectionExpressionHasBeenSet; }
+
+    /**
+     * <p>A string that identifies one or more attributes to retrieve from the table.
+     * These attributes can include scalars, sets, or elements of a JSON document. The
+     * attributes in the expression must be separated by commas.</p> <p>If no attribute
+     * names are specified, then all attributes are returned. If any of the requested
+     * attributes are not found, they do not appear in the result.</p> <p>For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Specifying
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline void SetProjectionExpression(const Aws::String& value) { m_projectionExpressionHasBeenSet = true; m_projectionExpression = value; }
+
+    /**
+     * <p>A string that identifies one or more attributes to retrieve from the table.
+     * These attributes can include scalars, sets, or elements of a JSON document. The
+     * attributes in the expression must be separated by commas.</p> <p>If no attribute
+     * names are specified, then all attributes are returned. If any of the requested
+     * attributes are not found, they do not appear in the result.</p> <p>For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Specifying
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline void SetProjectionExpression(Aws::String&& value) { m_projectionExpressionHasBeenSet = true; m_projectionExpression = std::move(value); }
+
+    /**
+     * <p>A string that identifies one or more attributes to retrieve from the table.
+     * These attributes can include scalars, sets, or elements of a JSON document. The
+     * attributes in the expression must be separated by commas.</p> <p>If no attribute
+     * names are specified, then all attributes are returned. If any of the requested
+     * attributes are not found, they do not appear in the result.</p> <p>For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Specifying
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline void SetProjectionExpression(const char* value) { m_projectionExpressionHasBeenSet = true; m_projectionExpression.assign(value); }
+
+    /**
+     * <p>A string that identifies one or more attributes to retrieve from the table.
+     * These attributes can include scalars, sets, or elements of a JSON document. The
+     * attributes in the expression must be separated by commas.</p> <p>If no attribute
+     * names are specified, then all attributes are returned. If any of the requested
+     * attributes are not found, they do not appear in the result.</p> <p>For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Specifying
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline GetItemRequest& WithProjectionExpression(const Aws::String& value) { SetProjectionExpression(value); return *this;}
+
+    /**
+     * <p>A string that identifies one or more attributes to retrieve from the table.
+     * These attributes can include scalars, sets, or elements of a JSON document. The
+     * attributes in the expression must be separated by commas.</p> <p>If no attribute
+     * names are specified, then all attributes are returned. If any of the requested
+     * attributes are not found, they do not appear in the result.</p> <p>For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Specifying
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline GetItemRequest& WithProjectionExpression(Aws::String&& value) { SetProjectionExpression(std::move(value)); return *this;}
+
+    /**
+     * <p>A string that identifies one or more attributes to retrieve from the table.
+     * These attributes can include scalars, sets, or elements of a JSON document. The
+     * attributes in the expression must be separated by commas.</p> <p>If no attribute
+     * names are specified, then all attributes are returned. If any of the requested
+     * attributes are not found, they do not appear in the result.</p> <p>For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Specifying
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline GetItemRequest& WithProjectionExpression(const char* value) { SetProjectionExpression(value); return *this;}
+
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression. The
+     * following are some use cases for using
+     * <code>ExpressionAttributeNames</code>:</p> <ul> <li> <p>To access an attribute
+     * whose name conflicts with a DynamoDB reserved word.</p> </li> <li> <p>To create
+     * a placeholder for repeating occurrences of an attribute name in an
+     * expression.</p> </li> <li> <p>To prevent special characters in an attribute name
+     * from being misinterpreted in an expression.</p> </li> </ul> <p>Use the <b>#</b>
+     * character in an expression to dereference an attribute name. For example,
+     * consider the following attribute name:</p> <ul> <li> <p> <code>Percentile</code>
+     * </p> </li> </ul> <p>The name of this attribute conflicts with a reserved word,
+     * so it cannot be used directly in an expression. (For the complete list of
+     * reserved words, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved
+     * Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this,
+     * you could specify the following for <code>ExpressionAttributeNames</code>:</p>
+     * <ul> <li> <p> <code>{"#P":"Percentile"}</code> </p> </li> </ul> <p>You could
+     * then use this substitution in an expression, as in this example:</p> <ul> <li>
+     * <p> <code>#P = :val</code> </p> </li> </ul>  <p>Tokens that begin with the
+     * <b>:</b> character are <i>expression attribute values</i>, which are
+     * placeholders for the actual value at runtime.</p>  <p>For more
+     * information on expression attribute names, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Specifying
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline const Aws::Map<Aws::String, Aws::String>& GetExpressionAttributeNames() const{ return m_expressionAttributeNames; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression. The
+     * following are some use cases for using
+     * <code>ExpressionAttributeNames</code>:</p> <ul> <li> <p>To access an attribute
+     * whose name conflicts with a DynamoDB reserved word.</p> </li> <li> <p>To create
+     * a placeholder for repeating occurrences of an attribute name in an
+     * expression.</p> </li> <li> <p>To prevent special characters in an attribute name
+     * from being misinterpreted in an expression.</p> </li> </ul> <p>Use the <b>#</b>
+     * character in an expression to dereference an attribute name. For example,
+     * consider the following attribute name:</p> <ul> <li> <p> <code>Percentile</code>
+     * </p> </li> </ul> <p>The name of this attribute conflicts with a reserved word,
+     * so it cannot be used directly in an expression. (For the complete list of
+     * reserved words, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved
+     * Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this,
+     * you could specify the following for <code>ExpressionAttributeNames</code>:</p>
+     * <ul> <li> <p> <code>{"#P":"Percentile"}</code> </p> </li> </ul> <p>You could
+     * then use this substitution in an expression, as in this example:</p> <ul> <li>
+     * <p> <code>#P = :val</code> </p> </li> </ul>  <p>Tokens that begin with the
+     * <b>:</b> character are <i>expression attribute values</i>, which are
+     * placeholders for the actual value at runtime.</p>  <p>For more
+     * information on expression attribute names, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Specifying
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline bool ExpressionAttributeNamesHasBeenSet() const { return m_expressionAttributeNamesHasBeenSet; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression. The
+     * following are some use cases for using
+     * <code>ExpressionAttributeNames</code>:</p> <ul> <li> <p>To access an attribute
+     * whose name conflicts with a DynamoDB reserved word.</p> </li> <li> <p>To create
+     * a placeholder for repeating occurrences of an attribute name in an
+     * expression.</p> </li> <li> <p>To prevent special characters in an attribute name
+     * from being misinterpreted in an expression.</p> </li> </ul> <p>Use the <b>#</b>
+     * character in an expression to dereference an attribute name. For example,
+     * consider the following attribute name:</p> <ul> <li> <p> <code>Percentile</code>
+     * </p> </li> </ul> <p>The name of this attribute conflicts with a reserved word,
+     * so it cannot be used directly in an expression. (For the complete list of
+     * reserved words, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved
+     * Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this,
+     * you could specify the following for <code>ExpressionAttributeNames</code>:</p>
+     * <ul> <li> <p> <code>{"#P":"Percentile"}</code> </p> </li> </ul> <p>You could
+     * then use this substitution in an expression, as in this example:</p> <ul> <li>
+     * <p> <code>#P = :val</code> </p> </li> </ul>  <p>Tokens that begin with the
+     * <b>:</b> character are <i>expression attribute values</i>, which are
+     * placeholders for the actual value at runtime.</p>  <p>For more
+     * information on expression attribute names, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Specifying
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline void SetExpressionAttributeNames(const Aws::Map<Aws::String, Aws::String>& value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames = value; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression. The
+     * following are some use cases for using
+     * <code>ExpressionAttributeNames</code>:</p> <ul> <li> <p>To access an attribute
+     * whose name conflicts with a DynamoDB reserved word.</p> </li> <li> <p>To create
+     * a placeholder for repeating occurrences of an attribute name in an
+     * expression.</p> </li> <li> <p>To prevent special characters in an attribute name
+     * from being misinterpreted in an expression.</p> </li> </ul> <p>Use the <b>#</b>
+     * character in an expression to dereference an attribute name. For example,
+     * consider the following attribute name:</p> <ul> <li> <p> <code>Percentile</code>
+     * </p> </li> </ul> <p>The name of this attribute conflicts with a reserved word,
+     * so it cannot be used directly in an expression. (For the complete list of
+     * reserved words, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved
+     * Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this,
+     * you could specify the following for <code>ExpressionAttributeNames</code>:</p>
+     * <ul> <li> <p> <code>{"#P":"Percentile"}</code> </p> </li> </ul> <p>You could
+     * then use this substitution in an expression, as in this example:</p> <ul> <li>
+     * <p> <code>#P = :val</code> </p> </li> </ul>  <p>Tokens that begin with the
+     * <b>:</b> character are <i>expression attribute values</i>, which are
+     * placeholders for the actual value at runtime.</p>  <p>For more
+     * information on expression attribute names, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Specifying
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline void SetExpressionAttributeNames(Aws::Map<Aws::String, Aws::String>&& value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames = std::move(value); }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression. The
+     * following are some use cases for using
+     * <code>ExpressionAttributeNames</code>:</p> <ul> <li> <p>To access an attribute
+     * whose name conflicts with a DynamoDB reserved word.</p> </li> <li> <p>To create
+     * a placeholder for repeating occurrences of an attribute name in an
+     * expression.</p> </li> <li> <p>To prevent special characters in an attribute name
+     * from being misinterpreted in an expression.</p> </li> </ul> <p>Use the <b>#</b>
+     * character in an expression to dereference an attribute name. For example,
+     * consider the following attribute name:</p> <ul> <li> <p> <code>Percentile</code>
+     * </p> </li> </ul> <p>The name of this attribute conflicts with a reserved word,
+     * so it cannot be used directly in an expression. (For the complete list of
+     * reserved words, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved
+     * Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this,
+     * you could specify the following for <code>ExpressionAttributeNames</code>:</p>
+     * <ul> <li> <p> <code>{"#P":"Percentile"}</code> </p> </li> </ul> <p>You could
+     * then use this substitution in an expression, as in this example:</p> <ul> <li>
+     * <p> <code>#P = :val</code> </p> </li> </ul>  <p>Tokens that begin with the
+     * <b>:</b> character are <i>expression attribute values</i>, which are
+     * placeholders for the actual value at runtime.</p>  <p>For more
+     * information on expression attribute names, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Specifying
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline GetItemRequest& WithExpressionAttributeNames(const Aws::Map<Aws::String, Aws::String>& value) { SetExpressionAttributeNames(value); return *this;}
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression. The
+     * following are some use cases for using
+     * <code>ExpressionAttributeNames</code>:</p> <ul> <li> <p>To access an attribute
+     * whose name conflicts with a DynamoDB reserved word.</p> </li> <li> <p>To create
+     * a placeholder for repeating occurrences of an attribute name in an
+     * expression.</p> </li> <li> <p>To prevent special characters in an attribute name
+     * from being misinterpreted in an expression.</p> </li> </ul> <p>Use the <b>#</b>
+     * character in an expression to dereference an attribute name. For example,
+     * consider the following attribute name:</p> <ul> <li> <p> <code>Percentile</code>
+     * </p> </li> </ul> <p>The name of this attribute conflicts with a reserved word,
+     * so it cannot be used directly in an expression. (For the complete list of
+     * reserved words, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved
+     * Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this,
+     * you could specify the following for <code>ExpressionAttributeNames</code>:</p>
+     * <ul> <li> <p> <code>{"#P":"Percentile"}</code> </p> </li> </ul> <p>You could
+     * then use this substitution in an expression, as in this example:</p> <ul> <li>
+     * <p> <code>#P = :val</code> </p> </li> </ul>  <p>Tokens that begin with the
+     * <b>:</b> character are <i>expression attribute values</i>, which are
+     * placeholders for the actual value at runtime.</p>  <p>For more
+     * information on expression attribute names, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Specifying
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline GetItemRequest& WithExpressionAttributeNames(Aws::Map<Aws::String, Aws::String>&& value) { SetExpressionAttributeNames(std::move(value)); return *this;}
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression. The
+     * following are some use cases for using
+     * <code>ExpressionAttributeNames</code>:</p> <ul> <li> <p>To access an attribute
+     * whose name conflicts with a DynamoDB reserved word.</p> </li> <li> <p>To create
+     * a placeholder for repeating occurrences of an attribute name in an
+     * expression.</p> </li> <li> <p>To prevent special characters in an attribute name
+     * from being misinterpreted in an expression.</p> </li> </ul> <p>Use the <b>#</b>
+     * character in an expression to dereference an attribute name. For example,
+     * consider the following attribute name:</p> <ul> <li> <p> <code>Percentile</code>
+     * </p> </li> </ul> <p>The name of this attribute conflicts with a reserved word,
+     * so it cannot be used directly in an expression. (For the complete list of
+     * reserved words, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved
+     * Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this,
+     * you could specify the following for <code>ExpressionAttributeNames</code>:</p>
+     * <ul> <li> <p> <code>{"#P":"Percentile"}</code> </p> </li> </ul> <p>You could
+     * then use this substitution in an expression, as in this example:</p> <ul> <li>
+     * <p> <code>#P = :val</code> </p> </li> </ul>  <p>Tokens that begin with the
+     * <b>:</b> character are <i>expression attribute values</i>, which are
+     * placeholders for the actual value at runtime.</p>  <p>For more
+     * information on expression attribute names, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Specifying
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline GetItemRequest& AddExpressionAttributeNames(const Aws::String& key, const Aws::String& value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames.emplace(key, value); return *this; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression. The
+     * following are some use cases for using
+     * <code>ExpressionAttributeNames</code>:</p> <ul> <li> <p>To access an attribute
+     * whose name conflicts with a DynamoDB reserved word.</p> </li> <li> <p>To create
+     * a placeholder for repeating occurrences of an attribute name in an
+     * expression.</p> </li> <li> <p>To prevent special characters in an attribute name
+     * from being misinterpreted in an expression.</p> </li> </ul> <p>Use the <b>#</b>
+     * character in an expression to dereference an attribute name. For example,
+     * consider the following attribute name:</p> <ul> <li> <p> <code>Percentile</code>
+     * </p> </li> </ul> <p>The name of this attribute conflicts with a reserved word,
+     * so it cannot be used directly in an expression. (For the complete list of
+     * reserved words, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved
+     * Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this,
+     * you could specify the following for <code>ExpressionAttributeNames</code>:</p>
+     * <ul> <li> <p> <code>{"#P":"Percentile"}</code> </p> </li> </ul> <p>You could
+     * then use this substitution in an expression, as in this example:</p> <ul> <li>
+     * <p> <code>#P = :val</code> </p> </li> </ul>  <p>Tokens that begin with the
+     * <b>:</b> character are <i>expression attribute values</i>, which are
+     * placeholders for the actual value at runtime.</p>  <p>For more
+     * information on expression attribute names, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Specifying
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline GetItemRequest& AddExpressionAttributeNames(Aws::String&& key, const Aws::String& value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression. The
+     * following are some use cases for using
+     * <code>ExpressionAttributeNames</code>:</p> <ul> <li> <p>To access an attribute
+     * whose name conflicts with a DynamoDB reserved word.</p> </li> <li> <p>To create
+     * a placeholder for repeating occurrences of an attribute name in an
+     * expression.</p> </li> <li> <p>To prevent special characters in an attribute name
+     * from being misinterpreted in an expression.</p> </li> </ul> <p>Use the <b>#</b>
+     * character in an expression to dereference an attribute name. For example,
+     * consider the following attribute name:</p> <ul> <li> <p> <code>Percentile</code>
+     * </p> </li> </ul> <p>The name of this attribute conflicts with a reserved word,
+     * so it cannot be used directly in an expression. (For the complete list of
+     * reserved words, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved
+     * Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this,
+     * you could specify the following for <code>ExpressionAttributeNames</code>:</p>
+     * <ul> <li> <p> <code>{"#P":"Percentile"}</code> </p> </li> </ul> <p>You could
+     * then use this substitution in an expression, as in this example:</p> <ul> <li>
+     * <p> <code>#P = :val</code> </p> </li> </ul>  <p>Tokens that begin with the
+     * <b>:</b> character are <i>expression attribute values</i>, which are
+     * placeholders for the actual value at runtime.</p>  <p>For more
+     * information on expression attribute names, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Specifying
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline GetItemRequest& AddExpressionAttributeNames(const Aws::String& key, Aws::String&& value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression. The
+     * following are some use cases for using
+     * <code>ExpressionAttributeNames</code>:</p> <ul> <li> <p>To access an attribute
+     * whose name conflicts with a DynamoDB reserved word.</p> </li> <li> <p>To create
+     * a placeholder for repeating occurrences of an attribute name in an
+     * expression.</p> </li> <li> <p>To prevent special characters in an attribute name
+     * from being misinterpreted in an expression.</p> </li> </ul> <p>Use the <b>#</b>
+     * character in an expression to dereference an attribute name. For example,
+     * consider the following attribute name:</p> <ul> <li> <p> <code>Percentile</code>
+     * </p> </li> </ul> <p>The name of this attribute conflicts with a reserved word,
+     * so it cannot be used directly in an expression. (For the complete list of
+     * reserved words, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved
+     * Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this,
+     * you could specify the following for <code>ExpressionAttributeNames</code>:</p>
+     * <ul> <li> <p> <code>{"#P":"Percentile"}</code> </p> </li> </ul> <p>You could
+     * then use this substitution in an expression, as in this example:</p> <ul> <li>
+     * <p> <code>#P = :val</code> </p> </li> </ul>  <p>Tokens that begin with the
+     * <b>:</b> character are <i>expression attribute values</i>, which are
+     * placeholders for the actual value at runtime.</p>  <p>For more
+     * information on expression attribute names, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Specifying
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline GetItemRequest& AddExpressionAttributeNames(Aws::String&& key, Aws::String&& value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression. The
+     * following are some use cases for using
+     * <code>ExpressionAttributeNames</code>:</p> <ul> <li> <p>To access an attribute
+     * whose name conflicts with a DynamoDB reserved word.</p> </li> <li> <p>To create
+     * a placeholder for repeating occurrences of an attribute name in an
+     * expression.</p> </li> <li> <p>To prevent special characters in an attribute name
+     * from being misinterpreted in an expression.</p> </li> </ul> <p>Use the <b>#</b>
+     * character in an expression to dereference an attribute name. For example,
+     * consider the following attribute name:</p> <ul> <li> <p> <code>Percentile</code>
+     * </p> </li> </ul> <p>The name of this attribute conflicts with a reserved word,
+     * so it cannot be used directly in an expression. (For the complete list of
+     * reserved words, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved
+     * Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this,
+     * you could specify the following for <code>ExpressionAttributeNames</code>:</p>
+     * <ul> <li> <p> <code>{"#P":"Percentile"}</code> </p> </li> </ul> <p>You could
+     * then use this substitution in an expression, as in this example:</p> <ul> <li>
+     * <p> <code>#P = :val</code> </p> </li> </ul>  <p>Tokens that begin with the
+     * <b>:</b> character are <i>expression attribute values</i>, which are
+     * placeholders for the actual value at runtime.</p>  <p>For more
+     * information on expression attribute names, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Specifying
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline GetItemRequest& AddExpressionAttributeNames(const char* key, Aws::String&& value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression. The
+     * following are some use cases for using
+     * <code>ExpressionAttributeNames</code>:</p> <ul> <li> <p>To access an attribute
+     * whose name conflicts with a DynamoDB reserved word.</p> </li> <li> <p>To create
+     * a placeholder for repeating occurrences of an attribute name in an
+     * expression.</p> </li> <li> <p>To prevent special characters in an attribute name
+     * from being misinterpreted in an expression.</p> </li> </ul> <p>Use the <b>#</b>
+     * character in an expression to dereference an attribute name. For example,
+     * consider the following attribute name:</p> <ul> <li> <p> <code>Percentile</code>
+     * </p> </li> </ul> <p>The name of this attribute conflicts with a reserved word,
+     * so it cannot be used directly in an expression. (For the complete list of
+     * reserved words, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved
+     * Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this,
+     * you could specify the following for <code>ExpressionAttributeNames</code>:</p>
+     * <ul> <li> <p> <code>{"#P":"Percentile"}</code> </p> </li> </ul> <p>You could
+     * then use this substitution in an expression, as in this example:</p> <ul> <li>
+     * <p> <code>#P = :val</code> </p> </li> </ul>  <p>Tokens that begin with the
+     * <b>:</b> character are <i>expression attribute values</i>, which are
+     * placeholders for the actual value at runtime.</p>  <p>For more
+     * information on expression attribute names, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Specifying
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline GetItemRequest& AddExpressionAttributeNames(Aws::String&& key, const char* value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>One or more substitution tokens for attribute names in an expression. The
+     * following are some use cases for using
+     * <code>ExpressionAttributeNames</code>:</p> <ul> <li> <p>To access an attribute
+     * whose name conflicts with a DynamoDB reserved word.</p> </li> <li> <p>To create
+     * a placeholder for repeating occurrences of an attribute name in an
+     * expression.</p> </li> <li> <p>To prevent special characters in an attribute name
+     * from being misinterpreted in an expression.</p> </li> </ul> <p>Use the <b>#</b>
+     * character in an expression to dereference an attribute name. For example,
+     * consider the following attribute name:</p> <ul> <li> <p> <code>Percentile</code>
+     * </p> </li> </ul> <p>The name of this attribute conflicts with a reserved word,
+     * so it cannot be used directly in an expression. (For the complete list of
+     * reserved words, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved
+     * Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this,
+     * you could specify the following for <code>ExpressionAttributeNames</code>:</p>
+     * <ul> <li> <p> <code>{"#P":"Percentile"}</code> </p> </li> </ul> <p>You could
+     * then use this substitution in an expression, as in this example:</p> <ul> <li>
+     * <p> <code>#P = :val</code> </p> </li> </ul>  <p>Tokens that begin with the
+     * <b>:</b> character are <i>expression attribute values</i>, which are
+     * placeholders for the actual value at runtime.</p>  <p>For more
+     * information on expression attribute names, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Specifying
+     * Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline GetItemRequest& AddExpressionAttributeNames(const char* key, const char* value) { m_expressionAttributeNamesHasBeenSet = true; m_expressionAttributeNames.emplace(key, value); return *this; }
+
+  private:
+
+    Aws::String m_tableName;
+    bool m_tableNameHasBeenSet;
+
+    Aws::Map<Aws::String, AttributeValue> m_key;
+    bool m_keyHasBeenSet;
+
+    Aws::Vector<Aws::String> m_attributesToGet;
+    bool m_attributesToGetHasBeenSet;
+
+    bool m_consistentRead;
+    bool m_consistentReadHasBeenSet;
+
+    ReturnConsumedCapacity m_returnConsumedCapacity;
+    bool m_returnConsumedCapacityHasBeenSet;
+
+    Aws::String m_projectionExpression;
+    bool m_projectionExpressionHasBeenSet;
+
+    Aws::Map<Aws::String, Aws::String> m_expressionAttributeNames;
+    bool m_expressionAttributeNamesHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/GetItemResult.h

@@ -0,0 +1,180 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <aws/dynamodb/model/ConsumedCapacity.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/dynamodb/model/AttributeValue.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+  /**
+   * <p>Represents the output of a <code>GetItem</code> operation.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/GetItemOutput">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API GetItemResult
+  {
+  public:
+    GetItemResult();
+    GetItemResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    GetItemResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, as specified
+     * by <code>ProjectionExpression</code>.</p>
+     */
+    inline const Aws::Map<Aws::String, AttributeValue>& GetItem() const{ return m_item; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, as specified
+     * by <code>ProjectionExpression</code>.</p>
+     */
+    inline void SetItem(const Aws::Map<Aws::String, AttributeValue>& value) { m_item = value; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, as specified
+     * by <code>ProjectionExpression</code>.</p>
+     */
+    inline void SetItem(Aws::Map<Aws::String, AttributeValue>&& value) { m_item = std::move(value); }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, as specified
+     * by <code>ProjectionExpression</code>.</p>
+     */
+    inline GetItemResult& WithItem(const Aws::Map<Aws::String, AttributeValue>& value) { SetItem(value); return *this;}
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, as specified
+     * by <code>ProjectionExpression</code>.</p>
+     */
+    inline GetItemResult& WithItem(Aws::Map<Aws::String, AttributeValue>&& value) { SetItem(std::move(value)); return *this;}
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, as specified
+     * by <code>ProjectionExpression</code>.</p>
+     */
+    inline GetItemResult& AddItem(const Aws::String& key, const AttributeValue& value) { m_item.emplace(key, value); return *this; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, as specified
+     * by <code>ProjectionExpression</code>.</p>
+     */
+    inline GetItemResult& AddItem(Aws::String&& key, const AttributeValue& value) { m_item.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, as specified
+     * by <code>ProjectionExpression</code>.</p>
+     */
+    inline GetItemResult& AddItem(const Aws::String& key, AttributeValue&& value) { m_item.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, as specified
+     * by <code>ProjectionExpression</code>.</p>
+     */
+    inline GetItemResult& AddItem(Aws::String&& key, AttributeValue&& value) { m_item.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, as specified
+     * by <code>ProjectionExpression</code>.</p>
+     */
+    inline GetItemResult& AddItem(const char* key, AttributeValue&& value) { m_item.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A map of attribute names to <code>AttributeValue</code> objects, as specified
+     * by <code>ProjectionExpression</code>.</p>
+     */
+    inline GetItemResult& AddItem(const char* key, const AttributeValue& value) { m_item.emplace(key, value); return *this; }
+
+
+    /**
+     * <p>The capacity units consumed by the <code>GetItem</code> operation. The data
+     * returned includes the total provisioned throughput consumed, along with
+     * statistics for the table and any indexes involved in the operation.
+     * <code>ConsumedCapacity</code> is only returned if the
+     * <code>ReturnConsumedCapacity</code> parameter was specified. For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ProvisionedThroughputIntro.html">Read/Write
+     * Capacity Mode</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline const ConsumedCapacity& GetConsumedCapacity() const{ return m_consumedCapacity; }
+
+    /**
+     * <p>The capacity units consumed by the <code>GetItem</code> operation. The data
+     * returned includes the total provisioned throughput consumed, along with
+     * statistics for the table and any indexes involved in the operation.
+     * <code>ConsumedCapacity</code> is only returned if the
+     * <code>ReturnConsumedCapacity</code> parameter was specified. For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ProvisionedThroughputIntro.html">Read/Write
+     * Capacity Mode</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline void SetConsumedCapacity(const ConsumedCapacity& value) { m_consumedCapacity = value; }
+
+    /**
+     * <p>The capacity units consumed by the <code>GetItem</code> operation. The data
+     * returned includes the total provisioned throughput consumed, along with
+     * statistics for the table and any indexes involved in the operation.
+     * <code>ConsumedCapacity</code> is only returned if the
+     * <code>ReturnConsumedCapacity</code> parameter was specified. For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ProvisionedThroughputIntro.html">Read/Write
+     * Capacity Mode</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline void SetConsumedCapacity(ConsumedCapacity&& value) { m_consumedCapacity = std::move(value); }
+
+    /**
+     * <p>The capacity units consumed by the <code>GetItem</code> operation. The data
+     * returned includes the total provisioned throughput consumed, along with
+     * statistics for the table and any indexes involved in the operation.
+     * <code>ConsumedCapacity</code> is only returned if the
+     * <code>ReturnConsumedCapacity</code> parameter was specified. For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ProvisionedThroughputIntro.html">Read/Write
+     * Capacity Mode</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline GetItemResult& WithConsumedCapacity(const ConsumedCapacity& value) { SetConsumedCapacity(value); return *this;}
+
+    /**
+     * <p>The capacity units consumed by the <code>GetItem</code> operation. The data
+     * returned includes the total provisioned throughput consumed, along with
+     * statistics for the table and any indexes involved in the operation.
+     * <code>ConsumedCapacity</code> is only returned if the
+     * <code>ReturnConsumedCapacity</code> parameter was specified. For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ProvisionedThroughputIntro.html">Read/Write
+     * Capacity Mode</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline GetItemResult& WithConsumedCapacity(ConsumedCapacity&& value) { SetConsumedCapacity(std::move(value)); return *this;}
+
+  private:
+
+    Aws::Map<Aws::String, AttributeValue> m_item;
+
+    ConsumedCapacity m_consumedCapacity;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/GlobalSecondaryIndex.h

@@ -0,0 +1,321 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/dynamodb/model/Projection.h>
+#include <aws/dynamodb/model/ProvisionedThroughput.h>
+#include <aws/dynamodb/model/KeySchemaElement.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents the properties of a global secondary index.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/GlobalSecondaryIndex">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API GlobalSecondaryIndex
+  {
+  public:
+    GlobalSecondaryIndex();
+    GlobalSecondaryIndex(Aws::Utils::Json::JsonView jsonValue);
+    GlobalSecondaryIndex& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The name of the global secondary index. The name must be unique among all
+     * other indexes on this table.</p>
+     */
+    inline const Aws::String& GetIndexName() const{ return m_indexName; }
+
+    /**
+     * <p>The name of the global secondary index. The name must be unique among all
+     * other indexes on this table.</p>
+     */
+    inline bool IndexNameHasBeenSet() const { return m_indexNameHasBeenSet; }
+
+    /**
+     * <p>The name of the global secondary index. The name must be unique among all
+     * other indexes on this table.</p>
+     */
+    inline void SetIndexName(const Aws::String& value) { m_indexNameHasBeenSet = true; m_indexName = value; }
+
+    /**
+     * <p>The name of the global secondary index. The name must be unique among all
+     * other indexes on this table.</p>
+     */
+    inline void SetIndexName(Aws::String&& value) { m_indexNameHasBeenSet = true; m_indexName = std::move(value); }
+
+    /**
+     * <p>The name of the global secondary index. The name must be unique among all
+     * other indexes on this table.</p>
+     */
+    inline void SetIndexName(const char* value) { m_indexNameHasBeenSet = true; m_indexName.assign(value); }
+
+    /**
+     * <p>The name of the global secondary index. The name must be unique among all
+     * other indexes on this table.</p>
+     */
+    inline GlobalSecondaryIndex& WithIndexName(const Aws::String& value) { SetIndexName(value); return *this;}
+
+    /**
+     * <p>The name of the global secondary index. The name must be unique among all
+     * other indexes on this table.</p>
+     */
+    inline GlobalSecondaryIndex& WithIndexName(Aws::String&& value) { SetIndexName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the global secondary index. The name must be unique among all
+     * other indexes on this table.</p>
+     */
+    inline GlobalSecondaryIndex& WithIndexName(const char* value) { SetIndexName(value); return *this;}
+
+
+    /**
+     * <p>The complete key schema for a global secondary index, which consists of one
+     * or more pairs of attribute names and key types:</p> <ul> <li> <p>
+     * <code>HASH</code> - partition key</p> </li> <li> <p> <code>RANGE</code> - sort
+     * key</p> </li> </ul>  <p>The partition key of an item is also known as its
+     * <i>hash attribute</i>. The term "hash attribute" derives from DynamoDB's usage
+     * of an internal hash function to evenly distribute data items across partitions,
+     * based on their partition key values.</p> <p>The sort key of an item is also
+     * known as its <i>range attribute</i>. The term "range attribute" derives from the
+     * way DynamoDB stores items with the same partition key physically close together,
+     * in sorted order by the sort key value.</p> 
+     */
+    inline const Aws::Vector<KeySchemaElement>& GetKeySchema() const{ return m_keySchema; }
+
+    /**
+     * <p>The complete key schema for a global secondary index, which consists of one
+     * or more pairs of attribute names and key types:</p> <ul> <li> <p>
+     * <code>HASH</code> - partition key</p> </li> <li> <p> <code>RANGE</code> - sort
+     * key</p> </li> </ul>  <p>The partition key of an item is also known as its
+     * <i>hash attribute</i>. The term "hash attribute" derives from DynamoDB's usage
+     * of an internal hash function to evenly distribute data items across partitions,
+     * based on their partition key values.</p> <p>The sort key of an item is also
+     * known as its <i>range attribute</i>. The term "range attribute" derives from the
+     * way DynamoDB stores items with the same partition key physically close together,
+     * in sorted order by the sort key value.</p> 
+     */
+    inline bool KeySchemaHasBeenSet() const { return m_keySchemaHasBeenSet; }
+
+    /**
+     * <p>The complete key schema for a global secondary index, which consists of one
+     * or more pairs of attribute names and key types:</p> <ul> <li> <p>
+     * <code>HASH</code> - partition key</p> </li> <li> <p> <code>RANGE</code> - sort
+     * key</p> </li> </ul>  <p>The partition key of an item is also known as its
+     * <i>hash attribute</i>. The term "hash attribute" derives from DynamoDB's usage
+     * of an internal hash function to evenly distribute data items across partitions,
+     * based on their partition key values.</p> <p>The sort key of an item is also
+     * known as its <i>range attribute</i>. The term "range attribute" derives from the
+     * way DynamoDB stores items with the same partition key physically close together,
+     * in sorted order by the sort key value.</p> 
+     */
+    inline void SetKeySchema(const Aws::Vector<KeySchemaElement>& value) { m_keySchemaHasBeenSet = true; m_keySchema = value; }
+
+    /**
+     * <p>The complete key schema for a global secondary index, which consists of one
+     * or more pairs of attribute names and key types:</p> <ul> <li> <p>
+     * <code>HASH</code> - partition key</p> </li> <li> <p> <code>RANGE</code> - sort
+     * key</p> </li> </ul>  <p>The partition key of an item is also known as its
+     * <i>hash attribute</i>. The term "hash attribute" derives from DynamoDB's usage
+     * of an internal hash function to evenly distribute data items across partitions,
+     * based on their partition key values.</p> <p>The sort key of an item is also
+     * known as its <i>range attribute</i>. The term "range attribute" derives from the
+     * way DynamoDB stores items with the same partition key physically close together,
+     * in sorted order by the sort key value.</p> 
+     */
+    inline void SetKeySchema(Aws::Vector<KeySchemaElement>&& value) { m_keySchemaHasBeenSet = true; m_keySchema = std::move(value); }
+
+    /**
+     * <p>The complete key schema for a global secondary index, which consists of one
+     * or more pairs of attribute names and key types:</p> <ul> <li> <p>
+     * <code>HASH</code> - partition key</p> </li> <li> <p> <code>RANGE</code> - sort
+     * key</p> </li> </ul>  <p>The partition key of an item is also known as its
+     * <i>hash attribute</i>. The term "hash attribute" derives from DynamoDB's usage
+     * of an internal hash function to evenly distribute data items across partitions,
+     * based on their partition key values.</p> <p>The sort key of an item is also
+     * known as its <i>range attribute</i>. The term "range attribute" derives from the
+     * way DynamoDB stores items with the same partition key physically close together,
+     * in sorted order by the sort key value.</p> 
+     */
+    inline GlobalSecondaryIndex& WithKeySchema(const Aws::Vector<KeySchemaElement>& value) { SetKeySchema(value); return *this;}
+
+    /**
+     * <p>The complete key schema for a global secondary index, which consists of one
+     * or more pairs of attribute names and key types:</p> <ul> <li> <p>
+     * <code>HASH</code> - partition key</p> </li> <li> <p> <code>RANGE</code> - sort
+     * key</p> </li> </ul>  <p>The partition key of an item is also known as its
+     * <i>hash attribute</i>. The term "hash attribute" derives from DynamoDB's usage
+     * of an internal hash function to evenly distribute data items across partitions,
+     * based on their partition key values.</p> <p>The sort key of an item is also
+     * known as its <i>range attribute</i>. The term "range attribute" derives from the
+     * way DynamoDB stores items with the same partition key physically close together,
+     * in sorted order by the sort key value.</p> 
+     */
+    inline GlobalSecondaryIndex& WithKeySchema(Aws::Vector<KeySchemaElement>&& value) { SetKeySchema(std::move(value)); return *this;}
+
+    /**
+     * <p>The complete key schema for a global secondary index, which consists of one
+     * or more pairs of attribute names and key types:</p> <ul> <li> <p>
+     * <code>HASH</code> - partition key</p> </li> <li> <p> <code>RANGE</code> - sort
+     * key</p> </li> </ul>  <p>The partition key of an item is also known as its
+     * <i>hash attribute</i>. The term "hash attribute" derives from DynamoDB's usage
+     * of an internal hash function to evenly distribute data items across partitions,
+     * based on their partition key values.</p> <p>The sort key of an item is also
+     * known as its <i>range attribute</i>. The term "range attribute" derives from the
+     * way DynamoDB stores items with the same partition key physically close together,
+     * in sorted order by the sort key value.</p> 
+     */
+    inline GlobalSecondaryIndex& AddKeySchema(const KeySchemaElement& value) { m_keySchemaHasBeenSet = true; m_keySchema.push_back(value); return *this; }
+
+    /**
+     * <p>The complete key schema for a global secondary index, which consists of one
+     * or more pairs of attribute names and key types:</p> <ul> <li> <p>
+     * <code>HASH</code> - partition key</p> </li> <li> <p> <code>RANGE</code> - sort
+     * key</p> </li> </ul>  <p>The partition key of an item is also known as its
+     * <i>hash attribute</i>. The term "hash attribute" derives from DynamoDB's usage
+     * of an internal hash function to evenly distribute data items across partitions,
+     * based on their partition key values.</p> <p>The sort key of an item is also
+     * known as its <i>range attribute</i>. The term "range attribute" derives from the
+     * way DynamoDB stores items with the same partition key physically close together,
+     * in sorted order by the sort key value.</p> 
+     */
+    inline GlobalSecondaryIndex& AddKeySchema(KeySchemaElement&& value) { m_keySchemaHasBeenSet = true; m_keySchema.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>Represents attributes that are copied (projected) from the table into the
+     * global secondary index. These are in addition to the primary key attributes and
+     * index key attributes, which are automatically projected. </p>
+     */
+    inline const Projection& GetProjection() const{ return m_projection; }
+
+    /**
+     * <p>Represents attributes that are copied (projected) from the table into the
+     * global secondary index. These are in addition to the primary key attributes and
+     * index key attributes, which are automatically projected. </p>
+     */
+    inline bool ProjectionHasBeenSet() const { return m_projectionHasBeenSet; }
+
+    /**
+     * <p>Represents attributes that are copied (projected) from the table into the
+     * global secondary index. These are in addition to the primary key attributes and
+     * index key attributes, which are automatically projected. </p>
+     */
+    inline void SetProjection(const Projection& value) { m_projectionHasBeenSet = true; m_projection = value; }
+
+    /**
+     * <p>Represents attributes that are copied (projected) from the table into the
+     * global secondary index. These are in addition to the primary key attributes and
+     * index key attributes, which are automatically projected. </p>
+     */
+    inline void SetProjection(Projection&& value) { m_projectionHasBeenSet = true; m_projection = std::move(value); }
+
+    /**
+     * <p>Represents attributes that are copied (projected) from the table into the
+     * global secondary index. These are in addition to the primary key attributes and
+     * index key attributes, which are automatically projected. </p>
+     */
+    inline GlobalSecondaryIndex& WithProjection(const Projection& value) { SetProjection(value); return *this;}
+
+    /**
+     * <p>Represents attributes that are copied (projected) from the table into the
+     * global secondary index. These are in addition to the primary key attributes and
+     * index key attributes, which are automatically projected. </p>
+     */
+    inline GlobalSecondaryIndex& WithProjection(Projection&& value) { SetProjection(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Represents the provisioned throughput settings for the specified global
+     * secondary index.</p> <p>For current minimum and maximum provisioned throughput
+     * values, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html">Limits</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline const ProvisionedThroughput& GetProvisionedThroughput() const{ return m_provisionedThroughput; }
+
+    /**
+     * <p>Represents the provisioned throughput settings for the specified global
+     * secondary index.</p> <p>For current minimum and maximum provisioned throughput
+     * values, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html">Limits</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline bool ProvisionedThroughputHasBeenSet() const { return m_provisionedThroughputHasBeenSet; }
+
+    /**
+     * <p>Represents the provisioned throughput settings for the specified global
+     * secondary index.</p> <p>For current minimum and maximum provisioned throughput
+     * values, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html">Limits</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline void SetProvisionedThroughput(const ProvisionedThroughput& value) { m_provisionedThroughputHasBeenSet = true; m_provisionedThroughput = value; }
+
+    /**
+     * <p>Represents the provisioned throughput settings for the specified global
+     * secondary index.</p> <p>For current minimum and maximum provisioned throughput
+     * values, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html">Limits</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline void SetProvisionedThroughput(ProvisionedThroughput&& value) { m_provisionedThroughputHasBeenSet = true; m_provisionedThroughput = std::move(value); }
+
+    /**
+     * <p>Represents the provisioned throughput settings for the specified global
+     * secondary index.</p> <p>For current minimum and maximum provisioned throughput
+     * values, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html">Limits</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline GlobalSecondaryIndex& WithProvisionedThroughput(const ProvisionedThroughput& value) { SetProvisionedThroughput(value); return *this;}
+
+    /**
+     * <p>Represents the provisioned throughput settings for the specified global
+     * secondary index.</p> <p>For current minimum and maximum provisioned throughput
+     * values, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html">Limits</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline GlobalSecondaryIndex& WithProvisionedThroughput(ProvisionedThroughput&& value) { SetProvisionedThroughput(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_indexName;
+    bool m_indexNameHasBeenSet;
+
+    Aws::Vector<KeySchemaElement> m_keySchema;
+    bool m_keySchemaHasBeenSet;
+
+    Projection m_projection;
+    bool m_projectionHasBeenSet;
+
+    ProvisionedThroughput m_provisionedThroughput;
+    bool m_provisionedThroughputHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/GlobalSecondaryIndexAutoScalingUpdate.h

@@ -0,0 +1,112 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/dynamodb/model/AutoScalingSettingsUpdate.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents the auto scaling settings of a global secondary index for a global
+   * table that will be modified.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/GlobalSecondaryIndexAutoScalingUpdate">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API GlobalSecondaryIndexAutoScalingUpdate
+  {
+  public:
+    GlobalSecondaryIndexAutoScalingUpdate();
+    GlobalSecondaryIndexAutoScalingUpdate(Aws::Utils::Json::JsonView jsonValue);
+    GlobalSecondaryIndexAutoScalingUpdate& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The name of the global secondary index.</p>
+     */
+    inline const Aws::String& GetIndexName() const{ return m_indexName; }
+
+    /**
+     * <p>The name of the global secondary index.</p>
+     */
+    inline bool IndexNameHasBeenSet() const { return m_indexNameHasBeenSet; }
+
+    /**
+     * <p>The name of the global secondary index.</p>
+     */
+    inline void SetIndexName(const Aws::String& value) { m_indexNameHasBeenSet = true; m_indexName = value; }
+
+    /**
+     * <p>The name of the global secondary index.</p>
+     */
+    inline void SetIndexName(Aws::String&& value) { m_indexNameHasBeenSet = true; m_indexName = std::move(value); }
+
+    /**
+     * <p>The name of the global secondary index.</p>
+     */
+    inline void SetIndexName(const char* value) { m_indexNameHasBeenSet = true; m_indexName.assign(value); }
+
+    /**
+     * <p>The name of the global secondary index.</p>
+     */
+    inline GlobalSecondaryIndexAutoScalingUpdate& WithIndexName(const Aws::String& value) { SetIndexName(value); return *this;}
+
+    /**
+     * <p>The name of the global secondary index.</p>
+     */
+    inline GlobalSecondaryIndexAutoScalingUpdate& WithIndexName(Aws::String&& value) { SetIndexName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the global secondary index.</p>
+     */
+    inline GlobalSecondaryIndexAutoScalingUpdate& WithIndexName(const char* value) { SetIndexName(value); return *this;}
+
+
+    
+    inline const AutoScalingSettingsUpdate& GetProvisionedWriteCapacityAutoScalingUpdate() const{ return m_provisionedWriteCapacityAutoScalingUpdate; }
+
+    
+    inline bool ProvisionedWriteCapacityAutoScalingUpdateHasBeenSet() const { return m_provisionedWriteCapacityAutoScalingUpdateHasBeenSet; }
+
+    
+    inline void SetProvisionedWriteCapacityAutoScalingUpdate(const AutoScalingSettingsUpdate& value) { m_provisionedWriteCapacityAutoScalingUpdateHasBeenSet = true; m_provisionedWriteCapacityAutoScalingUpdate = value; }
+
+    
+    inline void SetProvisionedWriteCapacityAutoScalingUpdate(AutoScalingSettingsUpdate&& value) { m_provisionedWriteCapacityAutoScalingUpdateHasBeenSet = true; m_provisionedWriteCapacityAutoScalingUpdate = std::move(value); }
+
+    
+    inline GlobalSecondaryIndexAutoScalingUpdate& WithProvisionedWriteCapacityAutoScalingUpdate(const AutoScalingSettingsUpdate& value) { SetProvisionedWriteCapacityAutoScalingUpdate(value); return *this;}
+
+    
+    inline GlobalSecondaryIndexAutoScalingUpdate& WithProvisionedWriteCapacityAutoScalingUpdate(AutoScalingSettingsUpdate&& value) { SetProvisionedWriteCapacityAutoScalingUpdate(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_indexName;
+    bool m_indexNameHasBeenSet;
+
+    AutoScalingSettingsUpdate m_provisionedWriteCapacityAutoScalingUpdate;
+    bool m_provisionedWriteCapacityAutoScalingUpdateHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/GlobalSecondaryIndexDescription.h

@@ -0,0 +1,552 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/dynamodb/model/Projection.h>
+#include <aws/dynamodb/model/IndexStatus.h>
+#include <aws/dynamodb/model/ProvisionedThroughputDescription.h>
+#include <aws/dynamodb/model/KeySchemaElement.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents the properties of a global secondary index.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/GlobalSecondaryIndexDescription">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API GlobalSecondaryIndexDescription
+  {
+  public:
+    GlobalSecondaryIndexDescription();
+    GlobalSecondaryIndexDescription(Aws::Utils::Json::JsonView jsonValue);
+    GlobalSecondaryIndexDescription& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The name of the global secondary index.</p>
+     */
+    inline const Aws::String& GetIndexName() const{ return m_indexName; }
+
+    /**
+     * <p>The name of the global secondary index.</p>
+     */
+    inline bool IndexNameHasBeenSet() const { return m_indexNameHasBeenSet; }
+
+    /**
+     * <p>The name of the global secondary index.</p>
+     */
+    inline void SetIndexName(const Aws::String& value) { m_indexNameHasBeenSet = true; m_indexName = value; }
+
+    /**
+     * <p>The name of the global secondary index.</p>
+     */
+    inline void SetIndexName(Aws::String&& value) { m_indexNameHasBeenSet = true; m_indexName = std::move(value); }
+
+    /**
+     * <p>The name of the global secondary index.</p>
+     */
+    inline void SetIndexName(const char* value) { m_indexNameHasBeenSet = true; m_indexName.assign(value); }
+
+    /**
+     * <p>The name of the global secondary index.</p>
+     */
+    inline GlobalSecondaryIndexDescription& WithIndexName(const Aws::String& value) { SetIndexName(value); return *this;}
+
+    /**
+     * <p>The name of the global secondary index.</p>
+     */
+    inline GlobalSecondaryIndexDescription& WithIndexName(Aws::String&& value) { SetIndexName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the global secondary index.</p>
+     */
+    inline GlobalSecondaryIndexDescription& WithIndexName(const char* value) { SetIndexName(value); return *this;}
+
+
+    /**
+     * <p>The complete key schema for a global secondary index, which consists of one
+     * or more pairs of attribute names and key types:</p> <ul> <li> <p>
+     * <code>HASH</code> - partition key</p> </li> <li> <p> <code>RANGE</code> - sort
+     * key</p> </li> </ul>  <p>The partition key of an item is also known as its
+     * <i>hash attribute</i>. The term "hash attribute" derives from DynamoDB's usage
+     * of an internal hash function to evenly distribute data items across partitions,
+     * based on their partition key values.</p> <p>The sort key of an item is also
+     * known as its <i>range attribute</i>. The term "range attribute" derives from the
+     * way DynamoDB stores items with the same partition key physically close together,
+     * in sorted order by the sort key value.</p> 
+     */
+    inline const Aws::Vector<KeySchemaElement>& GetKeySchema() const{ return m_keySchema; }
+
+    /**
+     * <p>The complete key schema for a global secondary index, which consists of one
+     * or more pairs of attribute names and key types:</p> <ul> <li> <p>
+     * <code>HASH</code> - partition key</p> </li> <li> <p> <code>RANGE</code> - sort
+     * key</p> </li> </ul>  <p>The partition key of an item is also known as its
+     * <i>hash attribute</i>. The term "hash attribute" derives from DynamoDB's usage
+     * of an internal hash function to evenly distribute data items across partitions,
+     * based on their partition key values.</p> <p>The sort key of an item is also
+     * known as its <i>range attribute</i>. The term "range attribute" derives from the
+     * way DynamoDB stores items with the same partition key physically close together,
+     * in sorted order by the sort key value.</p> 
+     */
+    inline bool KeySchemaHasBeenSet() const { return m_keySchemaHasBeenSet; }
+
+    /**
+     * <p>The complete key schema for a global secondary index, which consists of one
+     * or more pairs of attribute names and key types:</p> <ul> <li> <p>
+     * <code>HASH</code> - partition key</p> </li> <li> <p> <code>RANGE</code> - sort
+     * key</p> </li> </ul>  <p>The partition key of an item is also known as its
+     * <i>hash attribute</i>. The term "hash attribute" derives from DynamoDB's usage
+     * of an internal hash function to evenly distribute data items across partitions,
+     * based on their partition key values.</p> <p>The sort key of an item is also
+     * known as its <i>range attribute</i>. The term "range attribute" derives from the
+     * way DynamoDB stores items with the same partition key physically close together,
+     * in sorted order by the sort key value.</p> 
+     */
+    inline void SetKeySchema(const Aws::Vector<KeySchemaElement>& value) { m_keySchemaHasBeenSet = true; m_keySchema = value; }
+
+    /**
+     * <p>The complete key schema for a global secondary index, which consists of one
+     * or more pairs of attribute names and key types:</p> <ul> <li> <p>
+     * <code>HASH</code> - partition key</p> </li> <li> <p> <code>RANGE</code> - sort
+     * key</p> </li> </ul>  <p>The partition key of an item is also known as its
+     * <i>hash attribute</i>. The term "hash attribute" derives from DynamoDB's usage
+     * of an internal hash function to evenly distribute data items across partitions,
+     * based on their partition key values.</p> <p>The sort key of an item is also
+     * known as its <i>range attribute</i>. The term "range attribute" derives from the
+     * way DynamoDB stores items with the same partition key physically close together,
+     * in sorted order by the sort key value.</p> 
+     */
+    inline void SetKeySchema(Aws::Vector<KeySchemaElement>&& value) { m_keySchemaHasBeenSet = true; m_keySchema = std::move(value); }
+
+    /**
+     * <p>The complete key schema for a global secondary index, which consists of one
+     * or more pairs of attribute names and key types:</p> <ul> <li> <p>
+     * <code>HASH</code> - partition key</p> </li> <li> <p> <code>RANGE</code> - sort
+     * key</p> </li> </ul>  <p>The partition key of an item is also known as its
+     * <i>hash attribute</i>. The term "hash attribute" derives from DynamoDB's usage
+     * of an internal hash function to evenly distribute data items across partitions,
+     * based on their partition key values.</p> <p>The sort key of an item is also
+     * known as its <i>range attribute</i>. The term "range attribute" derives from the
+     * way DynamoDB stores items with the same partition key physically close together,
+     * in sorted order by the sort key value.</p> 
+     */
+    inline GlobalSecondaryIndexDescription& WithKeySchema(const Aws::Vector<KeySchemaElement>& value) { SetKeySchema(value); return *this;}
+
+    /**
+     * <p>The complete key schema for a global secondary index, which consists of one
+     * or more pairs of attribute names and key types:</p> <ul> <li> <p>
+     * <code>HASH</code> - partition key</p> </li> <li> <p> <code>RANGE</code> - sort
+     * key</p> </li> </ul>  <p>The partition key of an item is also known as its
+     * <i>hash attribute</i>. The term "hash attribute" derives from DynamoDB's usage
+     * of an internal hash function to evenly distribute data items across partitions,
+     * based on their partition key values.</p> <p>The sort key of an item is also
+     * known as its <i>range attribute</i>. The term "range attribute" derives from the
+     * way DynamoDB stores items with the same partition key physically close together,
+     * in sorted order by the sort key value.</p> 
+     */
+    inline GlobalSecondaryIndexDescription& WithKeySchema(Aws::Vector<KeySchemaElement>&& value) { SetKeySchema(std::move(value)); return *this;}
+
+    /**
+     * <p>The complete key schema for a global secondary index, which consists of one
+     * or more pairs of attribute names and key types:</p> <ul> <li> <p>
+     * <code>HASH</code> - partition key</p> </li> <li> <p> <code>RANGE</code> - sort
+     * key</p> </li> </ul>  <p>The partition key of an item is also known as its
+     * <i>hash attribute</i>. The term "hash attribute" derives from DynamoDB's usage
+     * of an internal hash function to evenly distribute data items across partitions,
+     * based on their partition key values.</p> <p>The sort key of an item is also
+     * known as its <i>range attribute</i>. The term "range attribute" derives from the
+     * way DynamoDB stores items with the same partition key physically close together,
+     * in sorted order by the sort key value.</p> 
+     */
+    inline GlobalSecondaryIndexDescription& AddKeySchema(const KeySchemaElement& value) { m_keySchemaHasBeenSet = true; m_keySchema.push_back(value); return *this; }
+
+    /**
+     * <p>The complete key schema for a global secondary index, which consists of one
+     * or more pairs of attribute names and key types:</p> <ul> <li> <p>
+     * <code>HASH</code> - partition key</p> </li> <li> <p> <code>RANGE</code> - sort
+     * key</p> </li> </ul>  <p>The partition key of an item is also known as its
+     * <i>hash attribute</i>. The term "hash attribute" derives from DynamoDB's usage
+     * of an internal hash function to evenly distribute data items across partitions,
+     * based on their partition key values.</p> <p>The sort key of an item is also
+     * known as its <i>range attribute</i>. The term "range attribute" derives from the
+     * way DynamoDB stores items with the same partition key physically close together,
+     * in sorted order by the sort key value.</p> 
+     */
+    inline GlobalSecondaryIndexDescription& AddKeySchema(KeySchemaElement&& value) { m_keySchemaHasBeenSet = true; m_keySchema.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>Represents attributes that are copied (projected) from the table into the
+     * global secondary index. These are in addition to the primary key attributes and
+     * index key attributes, which are automatically projected. </p>
+     */
+    inline const Projection& GetProjection() const{ return m_projection; }
+
+    /**
+     * <p>Represents attributes that are copied (projected) from the table into the
+     * global secondary index. These are in addition to the primary key attributes and
+     * index key attributes, which are automatically projected. </p>
+     */
+    inline bool ProjectionHasBeenSet() const { return m_projectionHasBeenSet; }
+
+    /**
+     * <p>Represents attributes that are copied (projected) from the table into the
+     * global secondary index. These are in addition to the primary key attributes and
+     * index key attributes, which are automatically projected. </p>
+     */
+    inline void SetProjection(const Projection& value) { m_projectionHasBeenSet = true; m_projection = value; }
+
+    /**
+     * <p>Represents attributes that are copied (projected) from the table into the
+     * global secondary index. These are in addition to the primary key attributes and
+     * index key attributes, which are automatically projected. </p>
+     */
+    inline void SetProjection(Projection&& value) { m_projectionHasBeenSet = true; m_projection = std::move(value); }
+
+    /**
+     * <p>Represents attributes that are copied (projected) from the table into the
+     * global secondary index. These are in addition to the primary key attributes and
+     * index key attributes, which are automatically projected. </p>
+     */
+    inline GlobalSecondaryIndexDescription& WithProjection(const Projection& value) { SetProjection(value); return *this;}
+
+    /**
+     * <p>Represents attributes that are copied (projected) from the table into the
+     * global secondary index. These are in addition to the primary key attributes and
+     * index key attributes, which are automatically projected. </p>
+     */
+    inline GlobalSecondaryIndexDescription& WithProjection(Projection&& value) { SetProjection(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The current state of the global secondary index:</p> <ul> <li> <p>
+     * <code>CREATING</code> - The index is being created.</p> </li> <li> <p>
+     * <code>UPDATING</code> - The index is being updated.</p> </li> <li> <p>
+     * <code>DELETING</code> - The index is being deleted.</p> </li> <li> <p>
+     * <code>ACTIVE</code> - The index is ready for use.</p> </li> </ul>
+     */
+    inline const IndexStatus& GetIndexStatus() const{ return m_indexStatus; }
+
+    /**
+     * <p>The current state of the global secondary index:</p> <ul> <li> <p>
+     * <code>CREATING</code> - The index is being created.</p> </li> <li> <p>
+     * <code>UPDATING</code> - The index is being updated.</p> </li> <li> <p>
+     * <code>DELETING</code> - The index is being deleted.</p> </li> <li> <p>
+     * <code>ACTIVE</code> - The index is ready for use.</p> </li> </ul>
+     */
+    inline bool IndexStatusHasBeenSet() const { return m_indexStatusHasBeenSet; }
+
+    /**
+     * <p>The current state of the global secondary index:</p> <ul> <li> <p>
+     * <code>CREATING</code> - The index is being created.</p> </li> <li> <p>
+     * <code>UPDATING</code> - The index is being updated.</p> </li> <li> <p>
+     * <code>DELETING</code> - The index is being deleted.</p> </li> <li> <p>
+     * <code>ACTIVE</code> - The index is ready for use.</p> </li> </ul>
+     */
+    inline void SetIndexStatus(const IndexStatus& value) { m_indexStatusHasBeenSet = true; m_indexStatus = value; }
+
+    /**
+     * <p>The current state of the global secondary index:</p> <ul> <li> <p>
+     * <code>CREATING</code> - The index is being created.</p> </li> <li> <p>
+     * <code>UPDATING</code> - The index is being updated.</p> </li> <li> <p>
+     * <code>DELETING</code> - The index is being deleted.</p> </li> <li> <p>
+     * <code>ACTIVE</code> - The index is ready for use.</p> </li> </ul>
+     */
+    inline void SetIndexStatus(IndexStatus&& value) { m_indexStatusHasBeenSet = true; m_indexStatus = std::move(value); }
+
+    /**
+     * <p>The current state of the global secondary index:</p> <ul> <li> <p>
+     * <code>CREATING</code> - The index is being created.</p> </li> <li> <p>
+     * <code>UPDATING</code> - The index is being updated.</p> </li> <li> <p>
+     * <code>DELETING</code> - The index is being deleted.</p> </li> <li> <p>
+     * <code>ACTIVE</code> - The index is ready for use.</p> </li> </ul>
+     */
+    inline GlobalSecondaryIndexDescription& WithIndexStatus(const IndexStatus& value) { SetIndexStatus(value); return *this;}
+
+    /**
+     * <p>The current state of the global secondary index:</p> <ul> <li> <p>
+     * <code>CREATING</code> - The index is being created.</p> </li> <li> <p>
+     * <code>UPDATING</code> - The index is being updated.</p> </li> <li> <p>
+     * <code>DELETING</code> - The index is being deleted.</p> </li> <li> <p>
+     * <code>ACTIVE</code> - The index is ready for use.</p> </li> </ul>
+     */
+    inline GlobalSecondaryIndexDescription& WithIndexStatus(IndexStatus&& value) { SetIndexStatus(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Indicates whether the index is currently backfilling. <i>Backfilling</i> is
+     * the process of reading items from the table and determining whether they can be
+     * added to the index. (Not all items will qualify: For example, a partition key
+     * cannot have any duplicate values.) If an item can be added to the index,
+     * DynamoDB will do so. After all items have been processed, the backfilling
+     * operation is complete and <code>Backfilling</code> is false.</p> <p>You can
+     * delete an index that is being created during the <code>Backfilling</code> phase
+     * when <code>IndexStatus</code> is set to CREATING and <code>Backfilling</code> is
+     * true. You can't delete the index that is being created when
+     * <code>IndexStatus</code> is set to CREATING and <code>Backfilling</code> is
+     * false. </p>  <p>For indexes that were created during a
+     * <code>CreateTable</code> operation, the <code>Backfilling</code> attribute does
+     * not appear in the <code>DescribeTable</code> output.</p> 
+     */
+    inline bool GetBackfilling() const{ return m_backfilling; }
+
+    /**
+     * <p>Indicates whether the index is currently backfilling. <i>Backfilling</i> is
+     * the process of reading items from the table and determining whether they can be
+     * added to the index. (Not all items will qualify: For example, a partition key
+     * cannot have any duplicate values.) If an item can be added to the index,
+     * DynamoDB will do so. After all items have been processed, the backfilling
+     * operation is complete and <code>Backfilling</code> is false.</p> <p>You can
+     * delete an index that is being created during the <code>Backfilling</code> phase
+     * when <code>IndexStatus</code> is set to CREATING and <code>Backfilling</code> is
+     * true. You can't delete the index that is being created when
+     * <code>IndexStatus</code> is set to CREATING and <code>Backfilling</code> is
+     * false. </p>  <p>For indexes that were created during a
+     * <code>CreateTable</code> operation, the <code>Backfilling</code> attribute does
+     * not appear in the <code>DescribeTable</code> output.</p> 
+     */
+    inline bool BackfillingHasBeenSet() const { return m_backfillingHasBeenSet; }
+
+    /**
+     * <p>Indicates whether the index is currently backfilling. <i>Backfilling</i> is
+     * the process of reading items from the table and determining whether they can be
+     * added to the index. (Not all items will qualify: For example, a partition key
+     * cannot have any duplicate values.) If an item can be added to the index,
+     * DynamoDB will do so. After all items have been processed, the backfilling
+     * operation is complete and <code>Backfilling</code> is false.</p> <p>You can
+     * delete an index that is being created during the <code>Backfilling</code> phase
+     * when <code>IndexStatus</code> is set to CREATING and <code>Backfilling</code> is
+     * true. You can't delete the index that is being created when
+     * <code>IndexStatus</code> is set to CREATING and <code>Backfilling</code> is
+     * false. </p>  <p>For indexes that were created during a
+     * <code>CreateTable</code> operation, the <code>Backfilling</code> attribute does
+     * not appear in the <code>DescribeTable</code> output.</p> 
+     */
+    inline void SetBackfilling(bool value) { m_backfillingHasBeenSet = true; m_backfilling = value; }
+
+    /**
+     * <p>Indicates whether the index is currently backfilling. <i>Backfilling</i> is
+     * the process of reading items from the table and determining whether they can be
+     * added to the index. (Not all items will qualify: For example, a partition key
+     * cannot have any duplicate values.) If an item can be added to the index,
+     * DynamoDB will do so. After all items have been processed, the backfilling
+     * operation is complete and <code>Backfilling</code> is false.</p> <p>You can
+     * delete an index that is being created during the <code>Backfilling</code> phase
+     * when <code>IndexStatus</code> is set to CREATING and <code>Backfilling</code> is
+     * true. You can't delete the index that is being created when
+     * <code>IndexStatus</code> is set to CREATING and <code>Backfilling</code> is
+     * false. </p>  <p>For indexes that were created during a
+     * <code>CreateTable</code> operation, the <code>Backfilling</code> attribute does
+     * not appear in the <code>DescribeTable</code> output.</p> 
+     */
+    inline GlobalSecondaryIndexDescription& WithBackfilling(bool value) { SetBackfilling(value); return *this;}
+
+
+    /**
+     * <p>Represents the provisioned throughput settings for the specified global
+     * secondary index.</p> <p>For current minimum and maximum provisioned throughput
+     * values, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html">Limits</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline const ProvisionedThroughputDescription& GetProvisionedThroughput() const{ return m_provisionedThroughput; }
+
+    /**
+     * <p>Represents the provisioned throughput settings for the specified global
+     * secondary index.</p> <p>For current minimum and maximum provisioned throughput
+     * values, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html">Limits</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline bool ProvisionedThroughputHasBeenSet() const { return m_provisionedThroughputHasBeenSet; }
+
+    /**
+     * <p>Represents the provisioned throughput settings for the specified global
+     * secondary index.</p> <p>For current minimum and maximum provisioned throughput
+     * values, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html">Limits</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline void SetProvisionedThroughput(const ProvisionedThroughputDescription& value) { m_provisionedThroughputHasBeenSet = true; m_provisionedThroughput = value; }
+
+    /**
+     * <p>Represents the provisioned throughput settings for the specified global
+     * secondary index.</p> <p>For current minimum and maximum provisioned throughput
+     * values, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html">Limits</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline void SetProvisionedThroughput(ProvisionedThroughputDescription&& value) { m_provisionedThroughputHasBeenSet = true; m_provisionedThroughput = std::move(value); }
+
+    /**
+     * <p>Represents the provisioned throughput settings for the specified global
+     * secondary index.</p> <p>For current minimum and maximum provisioned throughput
+     * values, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html">Limits</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline GlobalSecondaryIndexDescription& WithProvisionedThroughput(const ProvisionedThroughputDescription& value) { SetProvisionedThroughput(value); return *this;}
+
+    /**
+     * <p>Represents the provisioned throughput settings for the specified global
+     * secondary index.</p> <p>For current minimum and maximum provisioned throughput
+     * values, see <a
+     * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html">Limits</a>
+     * in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+     */
+    inline GlobalSecondaryIndexDescription& WithProvisionedThroughput(ProvisionedThroughputDescription&& value) { SetProvisionedThroughput(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The total size of the specified index, in bytes. DynamoDB updates this value
+     * approximately every six hours. Recent changes might not be reflected in this
+     * value.</p>
+     */
+    inline long long GetIndexSizeBytes() const{ return m_indexSizeBytes; }
+
+    /**
+     * <p>The total size of the specified index, in bytes. DynamoDB updates this value
+     * approximately every six hours. Recent changes might not be reflected in this
+     * value.</p>
+     */
+    inline bool IndexSizeBytesHasBeenSet() const { return m_indexSizeBytesHasBeenSet; }
+
+    /**
+     * <p>The total size of the specified index, in bytes. DynamoDB updates this value
+     * approximately every six hours. Recent changes might not be reflected in this
+     * value.</p>
+     */
+    inline void SetIndexSizeBytes(long long value) { m_indexSizeBytesHasBeenSet = true; m_indexSizeBytes = value; }
+
+    /**
+     * <p>The total size of the specified index, in bytes. DynamoDB updates this value
+     * approximately every six hours. Recent changes might not be reflected in this
+     * value.</p>
+     */
+    inline GlobalSecondaryIndexDescription& WithIndexSizeBytes(long long value) { SetIndexSizeBytes(value); return *this;}
+
+
+    /**
+     * <p>The number of items in the specified index. DynamoDB updates this value
+     * approximately every six hours. Recent changes might not be reflected in this
+     * value.</p>
+     */
+    inline long long GetItemCount() const{ return m_itemCount; }
+
+    /**
+     * <p>The number of items in the specified index. DynamoDB updates this value
+     * approximately every six hours. Recent changes might not be reflected in this
+     * value.</p>
+     */
+    inline bool ItemCountHasBeenSet() const { return m_itemCountHasBeenSet; }
+
+    /**
+     * <p>The number of items in the specified index. DynamoDB updates this value
+     * approximately every six hours. Recent changes might not be reflected in this
+     * value.</p>
+     */
+    inline void SetItemCount(long long value) { m_itemCountHasBeenSet = true; m_itemCount = value; }
+
+    /**
+     * <p>The number of items in the specified index. DynamoDB updates this value
+     * approximately every six hours. Recent changes might not be reflected in this
+     * value.</p>
+     */
+    inline GlobalSecondaryIndexDescription& WithItemCount(long long value) { SetItemCount(value); return *this;}
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that uniquely identifies the index.</p>
+     */
+    inline const Aws::String& GetIndexArn() const{ return m_indexArn; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that uniquely identifies the index.</p>
+     */
+    inline bool IndexArnHasBeenSet() const { return m_indexArnHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that uniquely identifies the index.</p>
+     */
+    inline void SetIndexArn(const Aws::String& value) { m_indexArnHasBeenSet = true; m_indexArn = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that uniquely identifies the index.</p>
+     */
+    inline void SetIndexArn(Aws::String&& value) { m_indexArnHasBeenSet = true; m_indexArn = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that uniquely identifies the index.</p>
+     */
+    inline void SetIndexArn(const char* value) { m_indexArnHasBeenSet = true; m_indexArn.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that uniquely identifies the index.</p>
+     */
+    inline GlobalSecondaryIndexDescription& WithIndexArn(const Aws::String& value) { SetIndexArn(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that uniquely identifies the index.</p>
+     */
+    inline GlobalSecondaryIndexDescription& WithIndexArn(Aws::String&& value) { SetIndexArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that uniquely identifies the index.</p>
+     */
+    inline GlobalSecondaryIndexDescription& WithIndexArn(const char* value) { SetIndexArn(value); return *this;}
+
+  private:
+
+    Aws::String m_indexName;
+    bool m_indexNameHasBeenSet;
+
+    Aws::Vector<KeySchemaElement> m_keySchema;
+    bool m_keySchemaHasBeenSet;
+
+    Projection m_projection;
+    bool m_projectionHasBeenSet;
+
+    IndexStatus m_indexStatus;
+    bool m_indexStatusHasBeenSet;
+
+    bool m_backfilling;
+    bool m_backfillingHasBeenSet;
+
+    ProvisionedThroughputDescription m_provisionedThroughput;
+    bool m_provisionedThroughputHasBeenSet;
+
+    long long m_indexSizeBytes;
+    bool m_indexSizeBytesHasBeenSet;
+
+    long long m_itemCount;
+    bool m_itemCountHasBeenSet;
+
+    Aws::String m_indexArn;
+    bool m_indexArnHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/GlobalSecondaryIndexInfo.h

@@ -0,0 +1,295 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/dynamodb/model/Projection.h>
+#include <aws/dynamodb/model/ProvisionedThroughput.h>
+#include <aws/dynamodb/model/KeySchemaElement.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents the properties of a global secondary index for the table when the
+   * backup was created.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/GlobalSecondaryIndexInfo">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API GlobalSecondaryIndexInfo
+  {
+  public:
+    GlobalSecondaryIndexInfo();
+    GlobalSecondaryIndexInfo(Aws::Utils::Json::JsonView jsonValue);
+    GlobalSecondaryIndexInfo& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The name of the global secondary index.</p>
+     */
+    inline const Aws::String& GetIndexName() const{ return m_indexName; }
+
+    /**
+     * <p>The name of the global secondary index.</p>
+     */
+    inline bool IndexNameHasBeenSet() const { return m_indexNameHasBeenSet; }
+
+    /**
+     * <p>The name of the global secondary index.</p>
+     */
+    inline void SetIndexName(const Aws::String& value) { m_indexNameHasBeenSet = true; m_indexName = value; }
+
+    /**
+     * <p>The name of the global secondary index.</p>
+     */
+    inline void SetIndexName(Aws::String&& value) { m_indexNameHasBeenSet = true; m_indexName = std::move(value); }
+
+    /**
+     * <p>The name of the global secondary index.</p>
+     */
+    inline void SetIndexName(const char* value) { m_indexNameHasBeenSet = true; m_indexName.assign(value); }
+
+    /**
+     * <p>The name of the global secondary index.</p>
+     */
+    inline GlobalSecondaryIndexInfo& WithIndexName(const Aws::String& value) { SetIndexName(value); return *this;}
+
+    /**
+     * <p>The name of the global secondary index.</p>
+     */
+    inline GlobalSecondaryIndexInfo& WithIndexName(Aws::String&& value) { SetIndexName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the global secondary index.</p>
+     */
+    inline GlobalSecondaryIndexInfo& WithIndexName(const char* value) { SetIndexName(value); return *this;}
+
+
+    /**
+     * <p>The complete key schema for a global secondary index, which consists of one
+     * or more pairs of attribute names and key types:</p> <ul> <li> <p>
+     * <code>HASH</code> - partition key</p> </li> <li> <p> <code>RANGE</code> - sort
+     * key</p> </li> </ul>  <p>The partition key of an item is also known as its
+     * <i>hash attribute</i>. The term "hash attribute" derives from DynamoDB's usage
+     * of an internal hash function to evenly distribute data items across partitions,
+     * based on their partition key values.</p> <p>The sort key of an item is also
+     * known as its <i>range attribute</i>. The term "range attribute" derives from the
+     * way DynamoDB stores items with the same partition key physically close together,
+     * in sorted order by the sort key value.</p> 
+     */
+    inline const Aws::Vector<KeySchemaElement>& GetKeySchema() const{ return m_keySchema; }
+
+    /**
+     * <p>The complete key schema for a global secondary index, which consists of one
+     * or more pairs of attribute names and key types:</p> <ul> <li> <p>
+     * <code>HASH</code> - partition key</p> </li> <li> <p> <code>RANGE</code> - sort
+     * key</p> </li> </ul>  <p>The partition key of an item is also known as its
+     * <i>hash attribute</i>. The term "hash attribute" derives from DynamoDB's usage
+     * of an internal hash function to evenly distribute data items across partitions,
+     * based on their partition key values.</p> <p>The sort key of an item is also
+     * known as its <i>range attribute</i>. The term "range attribute" derives from the
+     * way DynamoDB stores items with the same partition key physically close together,
+     * in sorted order by the sort key value.</p> 
+     */
+    inline bool KeySchemaHasBeenSet() const { return m_keySchemaHasBeenSet; }
+
+    /**
+     * <p>The complete key schema for a global secondary index, which consists of one
+     * or more pairs of attribute names and key types:</p> <ul> <li> <p>
+     * <code>HASH</code> - partition key</p> </li> <li> <p> <code>RANGE</code> - sort
+     * key</p> </li> </ul>  <p>The partition key of an item is also known as its
+     * <i>hash attribute</i>. The term "hash attribute" derives from DynamoDB's usage
+     * of an internal hash function to evenly distribute data items across partitions,
+     * based on their partition key values.</p> <p>The sort key of an item is also
+     * known as its <i>range attribute</i>. The term "range attribute" derives from the
+     * way DynamoDB stores items with the same partition key physically close together,
+     * in sorted order by the sort key value.</p> 
+     */
+    inline void SetKeySchema(const Aws::Vector<KeySchemaElement>& value) { m_keySchemaHasBeenSet = true; m_keySchema = value; }
+
+    /**
+     * <p>The complete key schema for a global secondary index, which consists of one
+     * or more pairs of attribute names and key types:</p> <ul> <li> <p>
+     * <code>HASH</code> - partition key</p> </li> <li> <p> <code>RANGE</code> - sort
+     * key</p> </li> </ul>  <p>The partition key of an item is also known as its
+     * <i>hash attribute</i>. The term "hash attribute" derives from DynamoDB's usage
+     * of an internal hash function to evenly distribute data items across partitions,
+     * based on their partition key values.</p> <p>The sort key of an item is also
+     * known as its <i>range attribute</i>. The term "range attribute" derives from the
+     * way DynamoDB stores items with the same partition key physically close together,
+     * in sorted order by the sort key value.</p> 
+     */
+    inline void SetKeySchema(Aws::Vector<KeySchemaElement>&& value) { m_keySchemaHasBeenSet = true; m_keySchema = std::move(value); }
+
+    /**
+     * <p>The complete key schema for a global secondary index, which consists of one
+     * or more pairs of attribute names and key types:</p> <ul> <li> <p>
+     * <code>HASH</code> - partition key</p> </li> <li> <p> <code>RANGE</code> - sort
+     * key</p> </li> </ul>  <p>The partition key of an item is also known as its
+     * <i>hash attribute</i>. The term "hash attribute" derives from DynamoDB's usage
+     * of an internal hash function to evenly distribute data items across partitions,
+     * based on their partition key values.</p> <p>The sort key of an item is also
+     * known as its <i>range attribute</i>. The term "range attribute" derives from the
+     * way DynamoDB stores items with the same partition key physically close together,
+     * in sorted order by the sort key value.</p> 
+     */
+    inline GlobalSecondaryIndexInfo& WithKeySchema(const Aws::Vector<KeySchemaElement>& value) { SetKeySchema(value); return *this;}
+
+    /**
+     * <p>The complete key schema for a global secondary index, which consists of one
+     * or more pairs of attribute names and key types:</p> <ul> <li> <p>
+     * <code>HASH</code> - partition key</p> </li> <li> <p> <code>RANGE</code> - sort
+     * key</p> </li> </ul>  <p>The partition key of an item is also known as its
+     * <i>hash attribute</i>. The term "hash attribute" derives from DynamoDB's usage
+     * of an internal hash function to evenly distribute data items across partitions,
+     * based on their partition key values.</p> <p>The sort key of an item is also
+     * known as its <i>range attribute</i>. The term "range attribute" derives from the
+     * way DynamoDB stores items with the same partition key physically close together,
+     * in sorted order by the sort key value.</p> 
+     */
+    inline GlobalSecondaryIndexInfo& WithKeySchema(Aws::Vector<KeySchemaElement>&& value) { SetKeySchema(std::move(value)); return *this;}
+
+    /**
+     * <p>The complete key schema for a global secondary index, which consists of one
+     * or more pairs of attribute names and key types:</p> <ul> <li> <p>
+     * <code>HASH</code> - partition key</p> </li> <li> <p> <code>RANGE</code> - sort
+     * key</p> </li> </ul>  <p>The partition key of an item is also known as its
+     * <i>hash attribute</i>. The term "hash attribute" derives from DynamoDB's usage
+     * of an internal hash function to evenly distribute data items across partitions,
+     * based on their partition key values.</p> <p>The sort key of an item is also
+     * known as its <i>range attribute</i>. The term "range attribute" derives from the
+     * way DynamoDB stores items with the same partition key physically close together,
+     * in sorted order by the sort key value.</p> 
+     */
+    inline GlobalSecondaryIndexInfo& AddKeySchema(const KeySchemaElement& value) { m_keySchemaHasBeenSet = true; m_keySchema.push_back(value); return *this; }
+
+    /**
+     * <p>The complete key schema for a global secondary index, which consists of one
+     * or more pairs of attribute names and key types:</p> <ul> <li> <p>
+     * <code>HASH</code> - partition key</p> </li> <li> <p> <code>RANGE</code> - sort
+     * key</p> </li> </ul>  <p>The partition key of an item is also known as its
+     * <i>hash attribute</i>. The term "hash attribute" derives from DynamoDB's usage
+     * of an internal hash function to evenly distribute data items across partitions,
+     * based on their partition key values.</p> <p>The sort key of an item is also
+     * known as its <i>range attribute</i>. The term "range attribute" derives from the
+     * way DynamoDB stores items with the same partition key physically close together,
+     * in sorted order by the sort key value.</p> 
+     */
+    inline GlobalSecondaryIndexInfo& AddKeySchema(KeySchemaElement&& value) { m_keySchemaHasBeenSet = true; m_keySchema.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>Represents attributes that are copied (projected) from the table into the
+     * global secondary index. These are in addition to the primary key attributes and
+     * index key attributes, which are automatically projected. </p>
+     */
+    inline const Projection& GetProjection() const{ return m_projection; }
+
+    /**
+     * <p>Represents attributes that are copied (projected) from the table into the
+     * global secondary index. These are in addition to the primary key attributes and
+     * index key attributes, which are automatically projected. </p>
+     */
+    inline bool ProjectionHasBeenSet() const { return m_projectionHasBeenSet; }
+
+    /**
+     * <p>Represents attributes that are copied (projected) from the table into the
+     * global secondary index. These are in addition to the primary key attributes and
+     * index key attributes, which are automatically projected. </p>
+     */
+    inline void SetProjection(const Projection& value) { m_projectionHasBeenSet = true; m_projection = value; }
+
+    /**
+     * <p>Represents attributes that are copied (projected) from the table into the
+     * global secondary index. These are in addition to the primary key attributes and
+     * index key attributes, which are automatically projected. </p>
+     */
+    inline void SetProjection(Projection&& value) { m_projectionHasBeenSet = true; m_projection = std::move(value); }
+
+    /**
+     * <p>Represents attributes that are copied (projected) from the table into the
+     * global secondary index. These are in addition to the primary key attributes and
+     * index key attributes, which are automatically projected. </p>
+     */
+    inline GlobalSecondaryIndexInfo& WithProjection(const Projection& value) { SetProjection(value); return *this;}
+
+    /**
+     * <p>Represents attributes that are copied (projected) from the table into the
+     * global secondary index. These are in addition to the primary key attributes and
+     * index key attributes, which are automatically projected. </p>
+     */
+    inline GlobalSecondaryIndexInfo& WithProjection(Projection&& value) { SetProjection(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Represents the provisioned throughput settings for the specified global
+     * secondary index. </p>
+     */
+    inline const ProvisionedThroughput& GetProvisionedThroughput() const{ return m_provisionedThroughput; }
+
+    /**
+     * <p>Represents the provisioned throughput settings for the specified global
+     * secondary index. </p>
+     */
+    inline bool ProvisionedThroughputHasBeenSet() const { return m_provisionedThroughputHasBeenSet; }
+
+    /**
+     * <p>Represents the provisioned throughput settings for the specified global
+     * secondary index. </p>
+     */
+    inline void SetProvisionedThroughput(const ProvisionedThroughput& value) { m_provisionedThroughputHasBeenSet = true; m_provisionedThroughput = value; }
+
+    /**
+     * <p>Represents the provisioned throughput settings for the specified global
+     * secondary index. </p>
+     */
+    inline void SetProvisionedThroughput(ProvisionedThroughput&& value) { m_provisionedThroughputHasBeenSet = true; m_provisionedThroughput = std::move(value); }
+
+    /**
+     * <p>Represents the provisioned throughput settings for the specified global
+     * secondary index. </p>
+     */
+    inline GlobalSecondaryIndexInfo& WithProvisionedThroughput(const ProvisionedThroughput& value) { SetProvisionedThroughput(value); return *this;}
+
+    /**
+     * <p>Represents the provisioned throughput settings for the specified global
+     * secondary index. </p>
+     */
+    inline GlobalSecondaryIndexInfo& WithProvisionedThroughput(ProvisionedThroughput&& value) { SetProvisionedThroughput(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_indexName;
+    bool m_indexNameHasBeenSet;
+
+    Aws::Vector<KeySchemaElement> m_keySchema;
+    bool m_keySchemaHasBeenSet;
+
+    Projection m_projection;
+    bool m_projectionHasBeenSet;
+
+    ProvisionedThroughput m_provisionedThroughput;
+    bool m_provisionedThroughputHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/GlobalSecondaryIndexUpdate.h

@@ -0,0 +1,182 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/dynamodb/model/UpdateGlobalSecondaryIndexAction.h>
+#include <aws/dynamodb/model/CreateGlobalSecondaryIndexAction.h>
+#include <aws/dynamodb/model/DeleteGlobalSecondaryIndexAction.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents one of the following:</p> <ul> <li> <p>A new global secondary
+   * index to be added to an existing table.</p> </li> <li> <p>New provisioned
+   * throughput parameters for an existing global secondary index.</p> </li> <li>
+   * <p>An existing global secondary index to be removed from an existing table.</p>
+   * </li> </ul><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/GlobalSecondaryIndexUpdate">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API GlobalSecondaryIndexUpdate
+  {
+  public:
+    GlobalSecondaryIndexUpdate();
+    GlobalSecondaryIndexUpdate(Aws::Utils::Json::JsonView jsonValue);
+    GlobalSecondaryIndexUpdate& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The name of an existing global secondary index, along with new provisioned
+     * throughput settings to be applied to that index.</p>
+     */
+    inline const UpdateGlobalSecondaryIndexAction& GetUpdate() const{ return m_update; }
+
+    /**
+     * <p>The name of an existing global secondary index, along with new provisioned
+     * throughput settings to be applied to that index.</p>
+     */
+    inline bool UpdateHasBeenSet() const { return m_updateHasBeenSet; }
+
+    /**
+     * <p>The name of an existing global secondary index, along with new provisioned
+     * throughput settings to be applied to that index.</p>
+     */
+    inline void SetUpdate(const UpdateGlobalSecondaryIndexAction& value) { m_updateHasBeenSet = true; m_update = value; }
+
+    /**
+     * <p>The name of an existing global secondary index, along with new provisioned
+     * throughput settings to be applied to that index.</p>
+     */
+    inline void SetUpdate(UpdateGlobalSecondaryIndexAction&& value) { m_updateHasBeenSet = true; m_update = std::move(value); }
+
+    /**
+     * <p>The name of an existing global secondary index, along with new provisioned
+     * throughput settings to be applied to that index.</p>
+     */
+    inline GlobalSecondaryIndexUpdate& WithUpdate(const UpdateGlobalSecondaryIndexAction& value) { SetUpdate(value); return *this;}
+
+    /**
+     * <p>The name of an existing global secondary index, along with new provisioned
+     * throughput settings to be applied to that index.</p>
+     */
+    inline GlobalSecondaryIndexUpdate& WithUpdate(UpdateGlobalSecondaryIndexAction&& value) { SetUpdate(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The parameters required for creating a global secondary index on an existing
+     * table:</p> <ul> <li> <p> <code>IndexName </code> </p> </li> <li> <p>
+     * <code>KeySchema </code> </p> </li> <li> <p> <code>AttributeDefinitions </code>
+     * </p> </li> <li> <p> <code>Projection </code> </p> </li> <li> <p>
+     * <code>ProvisionedThroughput </code> </p> </li> </ul>
+     */
+    inline const CreateGlobalSecondaryIndexAction& GetCreate() const{ return m_create; }
+
+    /**
+     * <p>The parameters required for creating a global secondary index on an existing
+     * table:</p> <ul> <li> <p> <code>IndexName </code> </p> </li> <li> <p>
+     * <code>KeySchema </code> </p> </li> <li> <p> <code>AttributeDefinitions </code>
+     * </p> </li> <li> <p> <code>Projection </code> </p> </li> <li> <p>
+     * <code>ProvisionedThroughput </code> </p> </li> </ul>
+     */
+    inline bool CreateHasBeenSet() const { return m_createHasBeenSet; }
+
+    /**
+     * <p>The parameters required for creating a global secondary index on an existing
+     * table:</p> <ul> <li> <p> <code>IndexName </code> </p> </li> <li> <p>
+     * <code>KeySchema </code> </p> </li> <li> <p> <code>AttributeDefinitions </code>
+     * </p> </li> <li> <p> <code>Projection </code> </p> </li> <li> <p>
+     * <code>ProvisionedThroughput </code> </p> </li> </ul>
+     */
+    inline void SetCreate(const CreateGlobalSecondaryIndexAction& value) { m_createHasBeenSet = true; m_create = value; }
+
+    /**
+     * <p>The parameters required for creating a global secondary index on an existing
+     * table:</p> <ul> <li> <p> <code>IndexName </code> </p> </li> <li> <p>
+     * <code>KeySchema </code> </p> </li> <li> <p> <code>AttributeDefinitions </code>
+     * </p> </li> <li> <p> <code>Projection </code> </p> </li> <li> <p>
+     * <code>ProvisionedThroughput </code> </p> </li> </ul>
+     */
+    inline void SetCreate(CreateGlobalSecondaryIndexAction&& value) { m_createHasBeenSet = true; m_create = std::move(value); }
+
+    /**
+     * <p>The parameters required for creating a global secondary index on an existing
+     * table:</p> <ul> <li> <p> <code>IndexName </code> </p> </li> <li> <p>
+     * <code>KeySchema </code> </p> </li> <li> <p> <code>AttributeDefinitions </code>
+     * </p> </li> <li> <p> <code>Projection </code> </p> </li> <li> <p>
+     * <code>ProvisionedThroughput </code> </p> </li> </ul>
+     */
+    inline GlobalSecondaryIndexUpdate& WithCreate(const CreateGlobalSecondaryIndexAction& value) { SetCreate(value); return *this;}
+
+    /**
+     * <p>The parameters required for creating a global secondary index on an existing
+     * table:</p> <ul> <li> <p> <code>IndexName </code> </p> </li> <li> <p>
+     * <code>KeySchema </code> </p> </li> <li> <p> <code>AttributeDefinitions </code>
+     * </p> </li> <li> <p> <code>Projection </code> </p> </li> <li> <p>
+     * <code>ProvisionedThroughput </code> </p> </li> </ul>
+     */
+    inline GlobalSecondaryIndexUpdate& WithCreate(CreateGlobalSecondaryIndexAction&& value) { SetCreate(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The name of an existing global secondary index to be removed.</p>
+     */
+    inline const DeleteGlobalSecondaryIndexAction& GetDelete() const{ return m_delete; }
+
+    /**
+     * <p>The name of an existing global secondary index to be removed.</p>
+     */
+    inline bool DeleteHasBeenSet() const { return m_deleteHasBeenSet; }
+
+    /**
+     * <p>The name of an existing global secondary index to be removed.</p>
+     */
+    inline void SetDelete(const DeleteGlobalSecondaryIndexAction& value) { m_deleteHasBeenSet = true; m_delete = value; }
+
+    /**
+     * <p>The name of an existing global secondary index to be removed.</p>
+     */
+    inline void SetDelete(DeleteGlobalSecondaryIndexAction&& value) { m_deleteHasBeenSet = true; m_delete = std::move(value); }
+
+    /**
+     * <p>The name of an existing global secondary index to be removed.</p>
+     */
+    inline GlobalSecondaryIndexUpdate& WithDelete(const DeleteGlobalSecondaryIndexAction& value) { SetDelete(value); return *this;}
+
+    /**
+     * <p>The name of an existing global secondary index to be removed.</p>
+     */
+    inline GlobalSecondaryIndexUpdate& WithDelete(DeleteGlobalSecondaryIndexAction&& value) { SetDelete(std::move(value)); return *this;}
+
+  private:
+
+    UpdateGlobalSecondaryIndexAction m_update;
+    bool m_updateHasBeenSet;
+
+    CreateGlobalSecondaryIndexAction m_create;
+    bool m_createHasBeenSet;
+
+    DeleteGlobalSecondaryIndexAction m_delete;
+    bool m_deleteHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/GlobalTable.h

@@ -0,0 +1,134 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/dynamodb/model/Replica.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents the properties of a global table.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/GlobalTable">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API GlobalTable
+  {
+  public:
+    GlobalTable();
+    GlobalTable(Aws::Utils::Json::JsonView jsonValue);
+    GlobalTable& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The global table name.</p>
+     */
+    inline const Aws::String& GetGlobalTableName() const{ return m_globalTableName; }
+
+    /**
+     * <p>The global table name.</p>
+     */
+    inline bool GlobalTableNameHasBeenSet() const { return m_globalTableNameHasBeenSet; }
+
+    /**
+     * <p>The global table name.</p>
+     */
+    inline void SetGlobalTableName(const Aws::String& value) { m_globalTableNameHasBeenSet = true; m_globalTableName = value; }
+
+    /**
+     * <p>The global table name.</p>
+     */
+    inline void SetGlobalTableName(Aws::String&& value) { m_globalTableNameHasBeenSet = true; m_globalTableName = std::move(value); }
+
+    /**
+     * <p>The global table name.</p>
+     */
+    inline void SetGlobalTableName(const char* value) { m_globalTableNameHasBeenSet = true; m_globalTableName.assign(value); }
+
+    /**
+     * <p>The global table name.</p>
+     */
+    inline GlobalTable& WithGlobalTableName(const Aws::String& value) { SetGlobalTableName(value); return *this;}
+
+    /**
+     * <p>The global table name.</p>
+     */
+    inline GlobalTable& WithGlobalTableName(Aws::String&& value) { SetGlobalTableName(std::move(value)); return *this;}
+
+    /**
+     * <p>The global table name.</p>
+     */
+    inline GlobalTable& WithGlobalTableName(const char* value) { SetGlobalTableName(value); return *this;}
+
+
+    /**
+     * <p>The Regions where the global table has replicas.</p>
+     */
+    inline const Aws::Vector<Replica>& GetReplicationGroup() const{ return m_replicationGroup; }
+
+    /**
+     * <p>The Regions where the global table has replicas.</p>
+     */
+    inline bool ReplicationGroupHasBeenSet() const { return m_replicationGroupHasBeenSet; }
+
+    /**
+     * <p>The Regions where the global table has replicas.</p>
+     */
+    inline void SetReplicationGroup(const Aws::Vector<Replica>& value) { m_replicationGroupHasBeenSet = true; m_replicationGroup = value; }
+
+    /**
+     * <p>The Regions where the global table has replicas.</p>
+     */
+    inline void SetReplicationGroup(Aws::Vector<Replica>&& value) { m_replicationGroupHasBeenSet = true; m_replicationGroup = std::move(value); }
+
+    /**
+     * <p>The Regions where the global table has replicas.</p>
+     */
+    inline GlobalTable& WithReplicationGroup(const Aws::Vector<Replica>& value) { SetReplicationGroup(value); return *this;}
+
+    /**
+     * <p>The Regions where the global table has replicas.</p>
+     */
+    inline GlobalTable& WithReplicationGroup(Aws::Vector<Replica>&& value) { SetReplicationGroup(std::move(value)); return *this;}
+
+    /**
+     * <p>The Regions where the global table has replicas.</p>
+     */
+    inline GlobalTable& AddReplicationGroup(const Replica& value) { m_replicationGroupHasBeenSet = true; m_replicationGroup.push_back(value); return *this; }
+
+    /**
+     * <p>The Regions where the global table has replicas.</p>
+     */
+    inline GlobalTable& AddReplicationGroup(Replica&& value) { m_replicationGroupHasBeenSet = true; m_replicationGroup.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_globalTableName;
+    bool m_globalTableNameHasBeenSet;
+
+    Aws::Vector<Replica> m_replicationGroup;
+    bool m_replicationGroupHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/GlobalTableDescription.h

@@ -0,0 +1,272 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/DateTime.h>
+#include <aws/dynamodb/model/GlobalTableStatus.h>
+#include <aws/dynamodb/model/ReplicaDescription.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Contains details about the global table.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/GlobalTableDescription">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API GlobalTableDescription
+  {
+  public:
+    GlobalTableDescription();
+    GlobalTableDescription(Aws::Utils::Json::JsonView jsonValue);
+    GlobalTableDescription& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The Regions where the global table has replicas.</p>
+     */
+    inline const Aws::Vector<ReplicaDescription>& GetReplicationGroup() const{ return m_replicationGroup; }
+
+    /**
+     * <p>The Regions where the global table has replicas.</p>
+     */
+    inline bool ReplicationGroupHasBeenSet() const { return m_replicationGroupHasBeenSet; }
+
+    /**
+     * <p>The Regions where the global table has replicas.</p>
+     */
+    inline void SetReplicationGroup(const Aws::Vector<ReplicaDescription>& value) { m_replicationGroupHasBeenSet = true; m_replicationGroup = value; }
+
+    /**
+     * <p>The Regions where the global table has replicas.</p>
+     */
+    inline void SetReplicationGroup(Aws::Vector<ReplicaDescription>&& value) { m_replicationGroupHasBeenSet = true; m_replicationGroup = std::move(value); }
+
+    /**
+     * <p>The Regions where the global table has replicas.</p>
+     */
+    inline GlobalTableDescription& WithReplicationGroup(const Aws::Vector<ReplicaDescription>& value) { SetReplicationGroup(value); return *this;}
+
+    /**
+     * <p>The Regions where the global table has replicas.</p>
+     */
+    inline GlobalTableDescription& WithReplicationGroup(Aws::Vector<ReplicaDescription>&& value) { SetReplicationGroup(std::move(value)); return *this;}
+
+    /**
+     * <p>The Regions where the global table has replicas.</p>
+     */
+    inline GlobalTableDescription& AddReplicationGroup(const ReplicaDescription& value) { m_replicationGroupHasBeenSet = true; m_replicationGroup.push_back(value); return *this; }
+
+    /**
+     * <p>The Regions where the global table has replicas.</p>
+     */
+    inline GlobalTableDescription& AddReplicationGroup(ReplicaDescription&& value) { m_replicationGroupHasBeenSet = true; m_replicationGroup.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>The unique identifier of the global table.</p>
+     */
+    inline const Aws::String& GetGlobalTableArn() const{ return m_globalTableArn; }
+
+    /**
+     * <p>The unique identifier of the global table.</p>
+     */
+    inline bool GlobalTableArnHasBeenSet() const { return m_globalTableArnHasBeenSet; }
+
+    /**
+     * <p>The unique identifier of the global table.</p>
+     */
+    inline void SetGlobalTableArn(const Aws::String& value) { m_globalTableArnHasBeenSet = true; m_globalTableArn = value; }
+
+    /**
+     * <p>The unique identifier of the global table.</p>
+     */
+    inline void SetGlobalTableArn(Aws::String&& value) { m_globalTableArnHasBeenSet = true; m_globalTableArn = std::move(value); }
+
+    /**
+     * <p>The unique identifier of the global table.</p>
+     */
+    inline void SetGlobalTableArn(const char* value) { m_globalTableArnHasBeenSet = true; m_globalTableArn.assign(value); }
+
+    /**
+     * <p>The unique identifier of the global table.</p>
+     */
+    inline GlobalTableDescription& WithGlobalTableArn(const Aws::String& value) { SetGlobalTableArn(value); return *this;}
+
+    /**
+     * <p>The unique identifier of the global table.</p>
+     */
+    inline GlobalTableDescription& WithGlobalTableArn(Aws::String&& value) { SetGlobalTableArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The unique identifier of the global table.</p>
+     */
+    inline GlobalTableDescription& WithGlobalTableArn(const char* value) { SetGlobalTableArn(value); return *this;}
+
+
+    /**
+     * <p>The creation time of the global table.</p>
+     */
+    inline const Aws::Utils::DateTime& GetCreationDateTime() const{ return m_creationDateTime; }
+
+    /**
+     * <p>The creation time of the global table.</p>
+     */
+    inline bool CreationDateTimeHasBeenSet() const { return m_creationDateTimeHasBeenSet; }
+
+    /**
+     * <p>The creation time of the global table.</p>
+     */
+    inline void SetCreationDateTime(const Aws::Utils::DateTime& value) { m_creationDateTimeHasBeenSet = true; m_creationDateTime = value; }
+
+    /**
+     * <p>The creation time of the global table.</p>
+     */
+    inline void SetCreationDateTime(Aws::Utils::DateTime&& value) { m_creationDateTimeHasBeenSet = true; m_creationDateTime = std::move(value); }
+
+    /**
+     * <p>The creation time of the global table.</p>
+     */
+    inline GlobalTableDescription& WithCreationDateTime(const Aws::Utils::DateTime& value) { SetCreationDateTime(value); return *this;}
+
+    /**
+     * <p>The creation time of the global table.</p>
+     */
+    inline GlobalTableDescription& WithCreationDateTime(Aws::Utils::DateTime&& value) { SetCreationDateTime(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The current state of the global table:</p> <ul> <li> <p>
+     * <code>CREATING</code> - The global table is being created.</p> </li> <li> <p>
+     * <code>UPDATING</code> - The global table is being updated.</p> </li> <li> <p>
+     * <code>DELETING</code> - The global table is being deleted.</p> </li> <li> <p>
+     * <code>ACTIVE</code> - The global table is ready for use.</p> </li> </ul>
+     */
+    inline const GlobalTableStatus& GetGlobalTableStatus() const{ return m_globalTableStatus; }
+
+    /**
+     * <p>The current state of the global table:</p> <ul> <li> <p>
+     * <code>CREATING</code> - The global table is being created.</p> </li> <li> <p>
+     * <code>UPDATING</code> - The global table is being updated.</p> </li> <li> <p>
+     * <code>DELETING</code> - The global table is being deleted.</p> </li> <li> <p>
+     * <code>ACTIVE</code> - The global table is ready for use.</p> </li> </ul>
+     */
+    inline bool GlobalTableStatusHasBeenSet() const { return m_globalTableStatusHasBeenSet; }
+
+    /**
+     * <p>The current state of the global table:</p> <ul> <li> <p>
+     * <code>CREATING</code> - The global table is being created.</p> </li> <li> <p>
+     * <code>UPDATING</code> - The global table is being updated.</p> </li> <li> <p>
+     * <code>DELETING</code> - The global table is being deleted.</p> </li> <li> <p>
+     * <code>ACTIVE</code> - The global table is ready for use.</p> </li> </ul>
+     */
+    inline void SetGlobalTableStatus(const GlobalTableStatus& value) { m_globalTableStatusHasBeenSet = true; m_globalTableStatus = value; }
+
+    /**
+     * <p>The current state of the global table:</p> <ul> <li> <p>
+     * <code>CREATING</code> - The global table is being created.</p> </li> <li> <p>
+     * <code>UPDATING</code> - The global table is being updated.</p> </li> <li> <p>
+     * <code>DELETING</code> - The global table is being deleted.</p> </li> <li> <p>
+     * <code>ACTIVE</code> - The global table is ready for use.</p> </li> </ul>
+     */
+    inline void SetGlobalTableStatus(GlobalTableStatus&& value) { m_globalTableStatusHasBeenSet = true; m_globalTableStatus = std::move(value); }
+
+    /**
+     * <p>The current state of the global table:</p> <ul> <li> <p>
+     * <code>CREATING</code> - The global table is being created.</p> </li> <li> <p>
+     * <code>UPDATING</code> - The global table is being updated.</p> </li> <li> <p>
+     * <code>DELETING</code> - The global table is being deleted.</p> </li> <li> <p>
+     * <code>ACTIVE</code> - The global table is ready for use.</p> </li> </ul>
+     */
+    inline GlobalTableDescription& WithGlobalTableStatus(const GlobalTableStatus& value) { SetGlobalTableStatus(value); return *this;}
+
+    /**
+     * <p>The current state of the global table:</p> <ul> <li> <p>
+     * <code>CREATING</code> - The global table is being created.</p> </li> <li> <p>
+     * <code>UPDATING</code> - The global table is being updated.</p> </li> <li> <p>
+     * <code>DELETING</code> - The global table is being deleted.</p> </li> <li> <p>
+     * <code>ACTIVE</code> - The global table is ready for use.</p> </li> </ul>
+     */
+    inline GlobalTableDescription& WithGlobalTableStatus(GlobalTableStatus&& value) { SetGlobalTableStatus(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The global table name.</p>
+     */
+    inline const Aws::String& GetGlobalTableName() const{ return m_globalTableName; }
+
+    /**
+     * <p>The global table name.</p>
+     */
+    inline bool GlobalTableNameHasBeenSet() const { return m_globalTableNameHasBeenSet; }
+
+    /**
+     * <p>The global table name.</p>
+     */
+    inline void SetGlobalTableName(const Aws::String& value) { m_globalTableNameHasBeenSet = true; m_globalTableName = value; }
+
+    /**
+     * <p>The global table name.</p>
+     */
+    inline void SetGlobalTableName(Aws::String&& value) { m_globalTableNameHasBeenSet = true; m_globalTableName = std::move(value); }
+
+    /**
+     * <p>The global table name.</p>
+     */
+    inline void SetGlobalTableName(const char* value) { m_globalTableNameHasBeenSet = true; m_globalTableName.assign(value); }
+
+    /**
+     * <p>The global table name.</p>
+     */
+    inline GlobalTableDescription& WithGlobalTableName(const Aws::String& value) { SetGlobalTableName(value); return *this;}
+
+    /**
+     * <p>The global table name.</p>
+     */
+    inline GlobalTableDescription& WithGlobalTableName(Aws::String&& value) { SetGlobalTableName(std::move(value)); return *this;}
+
+    /**
+     * <p>The global table name.</p>
+     */
+    inline GlobalTableDescription& WithGlobalTableName(const char* value) { SetGlobalTableName(value); return *this;}
+
+  private:
+
+    Aws::Vector<ReplicaDescription> m_replicationGroup;
+    bool m_replicationGroupHasBeenSet;
+
+    Aws::String m_globalTableArn;
+    bool m_globalTableArnHasBeenSet;
+
+    Aws::Utils::DateTime m_creationDateTime;
+    bool m_creationDateTimeHasBeenSet;
+
+    GlobalTableStatus m_globalTableStatus;
+    bool m_globalTableStatusHasBeenSet;
+
+    Aws::String m_globalTableName;
+    bool m_globalTableNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/GlobalTableGlobalSecondaryIndexSettingsUpdate.h

@@ -0,0 +1,166 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/dynamodb/model/AutoScalingSettingsUpdate.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents the settings of a global secondary index for a global table that
+   * will be modified.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/GlobalTableGlobalSecondaryIndexSettingsUpdate">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API GlobalTableGlobalSecondaryIndexSettingsUpdate
+  {
+  public:
+    GlobalTableGlobalSecondaryIndexSettingsUpdate();
+    GlobalTableGlobalSecondaryIndexSettingsUpdate(Aws::Utils::Json::JsonView jsonValue);
+    GlobalTableGlobalSecondaryIndexSettingsUpdate& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The name of the global secondary index. The name must be unique among all
+     * other indexes on this table.</p>
+     */
+    inline const Aws::String& GetIndexName() const{ return m_indexName; }
+
+    /**
+     * <p>The name of the global secondary index. The name must be unique among all
+     * other indexes on this table.</p>
+     */
+    inline bool IndexNameHasBeenSet() const { return m_indexNameHasBeenSet; }
+
+    /**
+     * <p>The name of the global secondary index. The name must be unique among all
+     * other indexes on this table.</p>
+     */
+    inline void SetIndexName(const Aws::String& value) { m_indexNameHasBeenSet = true; m_indexName = value; }
+
+    /**
+     * <p>The name of the global secondary index. The name must be unique among all
+     * other indexes on this table.</p>
+     */
+    inline void SetIndexName(Aws::String&& value) { m_indexNameHasBeenSet = true; m_indexName = std::move(value); }
+
+    /**
+     * <p>The name of the global secondary index. The name must be unique among all
+     * other indexes on this table.</p>
+     */
+    inline void SetIndexName(const char* value) { m_indexNameHasBeenSet = true; m_indexName.assign(value); }
+
+    /**
+     * <p>The name of the global secondary index. The name must be unique among all
+     * other indexes on this table.</p>
+     */
+    inline GlobalTableGlobalSecondaryIndexSettingsUpdate& WithIndexName(const Aws::String& value) { SetIndexName(value); return *this;}
+
+    /**
+     * <p>The name of the global secondary index. The name must be unique among all
+     * other indexes on this table.</p>
+     */
+    inline GlobalTableGlobalSecondaryIndexSettingsUpdate& WithIndexName(Aws::String&& value) { SetIndexName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the global secondary index. The name must be unique among all
+     * other indexes on this table.</p>
+     */
+    inline GlobalTableGlobalSecondaryIndexSettingsUpdate& WithIndexName(const char* value) { SetIndexName(value); return *this;}
+
+
+    /**
+     * <p>The maximum number of writes consumed per second before DynamoDB returns a
+     * <code>ThrottlingException.</code> </p>
+     */
+    inline long long GetProvisionedWriteCapacityUnits() const{ return m_provisionedWriteCapacityUnits; }
+
+    /**
+     * <p>The maximum number of writes consumed per second before DynamoDB returns a
+     * <code>ThrottlingException.</code> </p>
+     */
+    inline bool ProvisionedWriteCapacityUnitsHasBeenSet() const { return m_provisionedWriteCapacityUnitsHasBeenSet; }
+
+    /**
+     * <p>The maximum number of writes consumed per second before DynamoDB returns a
+     * <code>ThrottlingException.</code> </p>
+     */
+    inline void SetProvisionedWriteCapacityUnits(long long value) { m_provisionedWriteCapacityUnitsHasBeenSet = true; m_provisionedWriteCapacityUnits = value; }
+
+    /**
+     * <p>The maximum number of writes consumed per second before DynamoDB returns a
+     * <code>ThrottlingException.</code> </p>
+     */
+    inline GlobalTableGlobalSecondaryIndexSettingsUpdate& WithProvisionedWriteCapacityUnits(long long value) { SetProvisionedWriteCapacityUnits(value); return *this;}
+
+
+    /**
+     * <p>Auto scaling settings for managing a global secondary index's write capacity
+     * units.</p>
+     */
+    inline const AutoScalingSettingsUpdate& GetProvisionedWriteCapacityAutoScalingSettingsUpdate() const{ return m_provisionedWriteCapacityAutoScalingSettingsUpdate; }
+
+    /**
+     * <p>Auto scaling settings for managing a global secondary index's write capacity
+     * units.</p>
+     */
+    inline bool ProvisionedWriteCapacityAutoScalingSettingsUpdateHasBeenSet() const { return m_provisionedWriteCapacityAutoScalingSettingsUpdateHasBeenSet; }
+
+    /**
+     * <p>Auto scaling settings for managing a global secondary index's write capacity
+     * units.</p>
+     */
+    inline void SetProvisionedWriteCapacityAutoScalingSettingsUpdate(const AutoScalingSettingsUpdate& value) { m_provisionedWriteCapacityAutoScalingSettingsUpdateHasBeenSet = true; m_provisionedWriteCapacityAutoScalingSettingsUpdate = value; }
+
+    /**
+     * <p>Auto scaling settings for managing a global secondary index's write capacity
+     * units.</p>
+     */
+    inline void SetProvisionedWriteCapacityAutoScalingSettingsUpdate(AutoScalingSettingsUpdate&& value) { m_provisionedWriteCapacityAutoScalingSettingsUpdateHasBeenSet = true; m_provisionedWriteCapacityAutoScalingSettingsUpdate = std::move(value); }
+
+    /**
+     * <p>Auto scaling settings for managing a global secondary index's write capacity
+     * units.</p>
+     */
+    inline GlobalTableGlobalSecondaryIndexSettingsUpdate& WithProvisionedWriteCapacityAutoScalingSettingsUpdate(const AutoScalingSettingsUpdate& value) { SetProvisionedWriteCapacityAutoScalingSettingsUpdate(value); return *this;}
+
+    /**
+     * <p>Auto scaling settings for managing a global secondary index's write capacity
+     * units.</p>
+     */
+    inline GlobalTableGlobalSecondaryIndexSettingsUpdate& WithProvisionedWriteCapacityAutoScalingSettingsUpdate(AutoScalingSettingsUpdate&& value) { SetProvisionedWriteCapacityAutoScalingSettingsUpdate(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_indexName;
+    bool m_indexNameHasBeenSet;
+
+    long long m_provisionedWriteCapacityUnits;
+    bool m_provisionedWriteCapacityUnitsHasBeenSet;
+
+    AutoScalingSettingsUpdate m_provisionedWriteCapacityAutoScalingSettingsUpdate;
+    bool m_provisionedWriteCapacityAutoScalingSettingsUpdateHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/GlobalTableStatus.h

@@ -0,0 +1,33 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+  enum class GlobalTableStatus
+  {
+    NOT_SET,
+    CREATING,
+    ACTIVE,
+    DELETING,
+    UPDATING
+  };
+
+namespace GlobalTableStatusMapper
+{
+AWS_DYNAMODB_API GlobalTableStatus GetGlobalTableStatusForName(const Aws::String& name);
+
+AWS_DYNAMODB_API Aws::String GetNameForGlobalTableStatus(GlobalTableStatus value);
+} // namespace GlobalTableStatusMapper
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/IndexStatus.h

@@ -0,0 +1,33 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace DynamoDB
+{
+namespace Model
+{
+  enum class IndexStatus
+  {
+    NOT_SET,
+    CREATING,
+    UPDATING,
+    DELETING,
+    ACTIVE
+  };
+
+namespace IndexStatusMapper
+{
+AWS_DYNAMODB_API IndexStatus GetIndexStatusForName(const Aws::String& name);
+
+AWS_DYNAMODB_API Aws::String GetNameForIndexStatus(IndexStatus value);
+} // namespace IndexStatusMapper
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dynamodb/include/aws/dynamodb/model/ItemCollectionMetrics.h

@@ -0,0 +1,207 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dynamodb/DynamoDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/dynamodb/model/AttributeValue.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DynamoDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Information about item collections, if any, that were affected by the
+   * operation. <code>ItemCollectionMetrics</code> is only returned if the request
+   * asked for it. If the table does not have any local secondary indexes, this
+   * information is not returned in the response.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ItemCollectionMetrics">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DYNAMODB_API ItemCollectionMetrics
+  {
+  public:
+    ItemCollectionMetrics();
+    ItemCollectionMetrics(Aws::Utils::Json::JsonView jsonValue);
+    ItemCollectionMetrics& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The partition key value of the item collection. This value is the same as the
+     * partition key value of the item.</p>
+     */
+    inline const Aws::Map<Aws::String, AttributeValue>& GetItemCollectionKey() const{ return m_itemCollectionKey; }
+
+    /**
+     * <p>The partition key value of the item collection. This value is the same as the
+     * partition key value of the item.</p>
+     */
+    inline bool ItemCollectionKeyHasBeenSet() const { return m_itemCollectionKeyHasBeenSet; }
+
+    /**
+     * <p>The partition key value of the item collection. This value is the same as the
+     * partition key value of the item.</p>
+     */
+    inline void SetItemCollectionKey(const Aws::Map<Aws::String, AttributeValue>& value) { m_itemCollectionKeyHasBeenSet = true; m_itemCollectionKey = value; }
+
+    /**
+     * <p>The partition key value of the item collection. This value is the same as the
+     * partition key value of the item.</p>
+     */
+    inline void SetItemCollectionKey(Aws::Map<Aws::String, AttributeValue>&& value) { m_itemCollectionKeyHasBeenSet = true; m_itemCollectionKey = std::move(value); }
+
+    /**
+     * <p>The partition key value of the item collection. This value is the same as the
+     * partition key value of the item.</p>
+     */
+    inline ItemCollectionMetrics& WithItemCollectionKey(const Aws::Map<Aws::String, AttributeValue>& value) { SetItemCollectionKey(value); return *this;}
+
+    /**
+     * <p>The partition key value of the item collection. This value is the same as the
+     * partition key value of the item.</p>
+     */
+    inline ItemCollectionMetrics& WithItemCollectionKey(Aws::Map<Aws::String, AttributeValue>&& value) { SetItemCollectionKey(std::move(value)); return *this;}
+
+    /**
+     * <p>The partition key value of the item collection. This value is the same as the
+     * partition key value of the item.</p>
+     */
+    inline ItemCollectionMetrics& AddItemCollectionKey(const Aws::String& key, const AttributeValue& value) { m_itemCollectionKeyHasBeenSet = true; m_itemCollectionKey.emplace(key, value); return *this; }
+
+    /**
+     * <p>The partition key value of the item collection. This value is the same as the
+     * partition key value of the item.</p>
+     */
+    inline ItemCollectionMetrics& AddItemCollectionKey(Aws::String&& key, const AttributeValue& value) { m_itemCollectionKeyHasBeenSet = true; m_itemCollectionKey.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>The partition key value of the item collection. This value is the same as the
+     * partition key value of the item.</p>
+     */
+    inline ItemCollectionMetrics& AddItemCollectionKey(const Aws::String& key, AttributeValue&& value) { m_itemCollectionKeyHasBeenSet = true; m_itemCollectionKey.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>The partition key value of the item collection. This value is the same as the
+     * partition key value of the item.</p>
+     */
+    inline ItemCollectionMetrics& AddItemCollectionKey(Aws::String&& key, AttributeValue&& value) { m_itemCollectionKeyHasBeenSet = true; m_itemCollectionKey.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>The partition key value of the item collection. This value is the same as the
+     * partition key value of the item.</p>
+     */
+    inline ItemCollectionMetrics& AddItemCollectionKey(const char* key, AttributeValue&& value) { m_itemCollectionKeyHasBeenSet = true; m_itemCollectionKey.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>The partition key value of the item collection. This value is the same as the
+     * partition key value of the item.</p>
+     */
+    inline ItemCollectionMetrics& AddItemCollectionKey(const char* key, const AttributeValue& value) { m_itemCollectionKeyHasBeenSet = true; m_itemCollectionKey.emplace(key, value); return *this; }
+
+
+    /**
+     * <p>An estimate of item collection size, in gigabytes. This value is a
+     * two-element array containing a lower bound and an upper bound for the estimate.
+     * The estimate includes the size of all the items in the table, plus the size of
+     * all attributes projected into all of the local secondary indexes on that table.
+     * Use this estimate to measure whether a local secondary index is approaching its
+     * size limit.</p> <p>The estimate is subject to change over time; therefore, do
+     * not rely on the precision or accuracy of the estimate.</p>
+     */
+    inline const Aws::Vector<double>& GetSizeEstimateRangeGB() const{ return m_sizeEstimateRangeGB; }
+
+    /**
+     * <p>An estimate of item collection size, in gigabytes. This value is a
+     * two-element array containing a lower bound and an upper bound for the estimate.
+     * The estimate includes the size of all the items in the table, plus the size of
+     * all attributes projected into all of the local secondary indexes on that table.
+     * Use this estimate to measure whether a local secondary index is approaching its
+     * size limit.</p> <p>The estimate is subject to change over time; therefore, do
+     * not rely on the precision or accuracy of the estimate.</p>
+     */
+    inline bool SizeEstimateRangeGBHasBeenSet() const { return m_sizeEstimateRangeGBHasBeenSet; }
+
+    /**
+     * <p>An estimate of item collection size, in gigabytes. This value is a
+     * two-element array containing a lower bound and an upper bound for the estimate.
+     * The estimate includes the size of all the items in the table, plus the size of
+     * all attributes projected into all of the local secondary indexes on that table.
+     * Use this estimate to measure whether a local secondary index is approaching its
+     * size limit.</p> <p>The estimate is subject to change over time; therefore, do
+     * not rely on the precision or accuracy of the estimate.</p>
+     */
+    inline void SetSizeEstimateRangeGB(const Aws::Vector<double>& value) { m_sizeEstimateRangeGBHasBeenSet = true; m_sizeEstimateRangeGB = value; }
+
+    /**
+     * <p>An estimate of item collection size, in gigabytes. This value is a
+     * two-element array containing a lower bound and an upper bound for the estimate.
+     * The estimate includes the size of all the items in the table, plus the size of
+     * all attributes projected into all of the local secondary indexes on that table.
+     * Use this estimate to measure whether a local secondary index is approaching its
+     * size limit.</p> <p>The estimate is subject to change over time; therefore, do
+     * not rely on the precision or accuracy of the estimate.</p>
+     */
+    inline void SetSizeEstimateRangeGB(Aws::Vector<double>&& value) { m_sizeEstimateRangeGBHasBeenSet = true; m_sizeEstimateRangeGB = std::move(value); }
+
+    /**
+     * <p>An estimate of item collection size, in gigabytes. This value is a
+     * two-element array containing a lower bound and an upper bound for the estimate.
+     * The estimate includes the size of all the items in the table, plus the size of
+     * all attributes projected into all of the local secondary indexes on that table.
+     * Use this estimate to measure whether a local secondary index is approaching its
+     * size limit.</p> <p>The estimate is subject to change over time; therefore, do
+     * not rely on the precision or accuracy of the estimate.</p>
+     */
+    inline ItemCollectionMetrics& WithSizeEstimateRangeGB(const Aws::Vector<double>& value) { SetSizeEstimateRangeGB(value); return *this;}
+
+    /**
+     * <p>An estimate of item collection size, in gigabytes. This value is a
+     * two-element array containing a lower bound and an upper bound for the estimate.
+     * The estimate includes the size of all the items in the table, plus the size of
+     * all attributes projected into all of the local secondary indexes on that table.
+     * Use this estimate to measure whether a local secondary index is approaching its
+     * size limit.</p> <p>The estimate is subject to change over time; therefore, do
+     * not rely on the precision or accuracy of the estimate.</p>
+     */
+    inline ItemCollectionMetrics& WithSizeEstimateRangeGB(Aws::Vector<double>&& value) { SetSizeEstimateRangeGB(std::move(value)); return *this;}
+
+    /**
+     * <p>An estimate of item collection size, in gigabytes. This value is a
+     * two-element array containing a lower bound and an upper bound for the estimate.
+     * The estimate includes the size of all the items in the table, plus the size of
+     * all attributes projected into all of the local secondary indexes on that table.
+     * Use this estimate to measure whether a local secondary index is approaching its
+     * size limit.</p> <p>The estimate is subject to change over time; therefore, do
+     * not rely on the precision or accuracy of the estimate.</p>
+     */
+    inline ItemCollectionMetrics& AddSizeEstimateRangeGB(double value) { m_sizeEstimateRangeGBHasBeenSet = true; m_sizeEstimateRangeGB.push_back(value); return *this; }
+
+  private:
+
+    Aws::Map<Aws::String, AttributeValue> m_itemCollectionKey;
+    bool m_itemCollectionKeyHasBeenSet;
+
+    Aws::Vector<double> m_sizeEstimateRangeGB;
+    bool m_sizeEstimateRangeGBHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DynamoDB
+} // namespace Aws