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

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/SimpleDBClient.h

@@ -0,0 +1,765 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/sdb/SimpleDBErrors.h>
+#include <aws/core/client/AWSError.h>
+#include <aws/core/client/ClientConfiguration.h>
+#include <aws/core/AmazonSerializableWebServiceRequest.h>
+#include <aws/core/client/AWSClient.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/sdb/model/DomainMetadataResult.h>
+#include <aws/sdb/model/GetAttributesResult.h>
+#include <aws/sdb/model/ListDomainsResult.h>
+#include <aws/sdb/model/SelectResult.h>
+#include <aws/core/NoResult.h>
+#include <aws/core/client/AsyncCallerContext.h>
+#include <aws/core/http/HttpTypes.h>
+#include <future>
+#include <functional>
+
+namespace Aws
+{
+
+namespace Http
+{
+  class HttpClient;
+  class HttpClientFactory;
+} // namespace Http
+
+namespace Utils
+{
+  template< typename R, typename E> class Outcome;
+
+namespace Threading
+{
+  class Executor;
+} // namespace Threading
+
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+
+namespace Auth
+{
+  class AWSCredentials;
+  class AWSCredentialsProvider;
+} // namespace Auth
+
+namespace Client
+{
+  class RetryStrategy;
+} // namespace Client
+
+namespace SimpleDB
+{
+
+namespace Model
+{
+        class BatchDeleteAttributesRequest;
+        class BatchPutAttributesRequest;
+        class CreateDomainRequest;
+        class DeleteAttributesRequest;
+        class DeleteDomainRequest;
+        class DomainMetadataRequest;
+        class GetAttributesRequest;
+        class ListDomainsRequest;
+        class PutAttributesRequest;
+        class SelectRequest;
+
+        typedef Aws::Utils::Outcome<Aws::NoResult, SimpleDBError> BatchDeleteAttributesOutcome;
+        typedef Aws::Utils::Outcome<Aws::NoResult, SimpleDBError> BatchPutAttributesOutcome;
+        typedef Aws::Utils::Outcome<Aws::NoResult, SimpleDBError> CreateDomainOutcome;
+        typedef Aws::Utils::Outcome<Aws::NoResult, SimpleDBError> DeleteAttributesOutcome;
+        typedef Aws::Utils::Outcome<Aws::NoResult, SimpleDBError> DeleteDomainOutcome;
+        typedef Aws::Utils::Outcome<DomainMetadataResult, SimpleDBError> DomainMetadataOutcome;
+        typedef Aws::Utils::Outcome<GetAttributesResult, SimpleDBError> GetAttributesOutcome;
+        typedef Aws::Utils::Outcome<ListDomainsResult, SimpleDBError> ListDomainsOutcome;
+        typedef Aws::Utils::Outcome<Aws::NoResult, SimpleDBError> PutAttributesOutcome;
+        typedef Aws::Utils::Outcome<SelectResult, SimpleDBError> SelectOutcome;
+
+        typedef std::future<BatchDeleteAttributesOutcome> BatchDeleteAttributesOutcomeCallable;
+        typedef std::future<BatchPutAttributesOutcome> BatchPutAttributesOutcomeCallable;
+        typedef std::future<CreateDomainOutcome> CreateDomainOutcomeCallable;
+        typedef std::future<DeleteAttributesOutcome> DeleteAttributesOutcomeCallable;
+        typedef std::future<DeleteDomainOutcome> DeleteDomainOutcomeCallable;
+        typedef std::future<DomainMetadataOutcome> DomainMetadataOutcomeCallable;
+        typedef std::future<GetAttributesOutcome> GetAttributesOutcomeCallable;
+        typedef std::future<ListDomainsOutcome> ListDomainsOutcomeCallable;
+        typedef std::future<PutAttributesOutcome> PutAttributesOutcomeCallable;
+        typedef std::future<SelectOutcome> SelectOutcomeCallable;
+} // namespace Model
+
+  class SimpleDBClient;
+
+    typedef std::function<void(const SimpleDBClient*, const Model::BatchDeleteAttributesRequest&, const Model::BatchDeleteAttributesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > BatchDeleteAttributesResponseReceivedHandler;
+    typedef std::function<void(const SimpleDBClient*, const Model::BatchPutAttributesRequest&, const Model::BatchPutAttributesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > BatchPutAttributesResponseReceivedHandler;
+    typedef std::function<void(const SimpleDBClient*, const Model::CreateDomainRequest&, const Model::CreateDomainOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateDomainResponseReceivedHandler;
+    typedef std::function<void(const SimpleDBClient*, const Model::DeleteAttributesRequest&, const Model::DeleteAttributesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteAttributesResponseReceivedHandler;
+    typedef std::function<void(const SimpleDBClient*, const Model::DeleteDomainRequest&, const Model::DeleteDomainOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteDomainResponseReceivedHandler;
+    typedef std::function<void(const SimpleDBClient*, const Model::DomainMetadataRequest&, const Model::DomainMetadataOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DomainMetadataResponseReceivedHandler;
+    typedef std::function<void(const SimpleDBClient*, const Model::GetAttributesRequest&, const Model::GetAttributesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetAttributesResponseReceivedHandler;
+    typedef std::function<void(const SimpleDBClient*, const Model::ListDomainsRequest&, const Model::ListDomainsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListDomainsResponseReceivedHandler;
+    typedef std::function<void(const SimpleDBClient*, const Model::PutAttributesRequest&, const Model::PutAttributesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutAttributesResponseReceivedHandler;
+    typedef std::function<void(const SimpleDBClient*, const Model::SelectRequest&, const Model::SelectOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > SelectResponseReceivedHandler;
+
+  /**
+   * Amazon SimpleDB is a web service providing the core database functions of data
+   * indexing and querying in the cloud. By offloading the time and effort associated
+   * with building and operating a web-scale database, SimpleDB provides developers
+   * the freedom to focus on application development. <p> A traditional, clustered
+   * relational database requires a sizable upfront capital outlay, is complex to
+   * design, and often requires extensive and repetitive database administration.
+   * Amazon SimpleDB is dramatically simpler, requiring no schema, automatically
+   * indexing your data and providing a simple API for storage and access. This
+   * approach eliminates the administrative burden of data modeling, index
+   * maintenance, and performance tuning. Developers gain access to this
+   * functionality within Amazon's proven computing environment, are able to scale
+   * instantly, and pay only for what they use. </p> <p> Visit <a
+   * href="http://aws.amazon.com/simpledb/">http://aws.amazon.com/simpledb/</a> for
+   * more information. </p>
+   */
+  class AWS_SIMPLEDB_API SimpleDBClient : public Aws::Client::AWSXMLClient
+  {
+    public:
+      typedef Aws::Client::AWSXMLClient BASECLASS;
+
+       /**
+        * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config
+        * is not specified, it will be initialized to default values.
+        */
+        SimpleDBClient(const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());
+
+       /**
+        * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config
+        * is not specified, it will be initialized to default values.
+        */
+        SimpleDBClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());
+
+       /**
+        * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied,
+        * the default http client factory will be used
+        */
+        SimpleDBClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
+            const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());
+
+        virtual ~SimpleDBClient();
+
+
+       /**
+        * Converts any request object to a presigned URL with the GET method, using region for the signer and a timeout of 15 minutes.
+        */
+        Aws::String ConvertRequestToPresignedUrl(const Aws::AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const;
+
+
+        /**
+         * <p> Performs multiple DeleteAttributes operations in a single call, which
+         * reduces round trips and latencies. This enables Amazon SimpleDB to optimize
+         * requests, which generally yields better throughput. </p> <p> The following
+         * limitations are enforced for this operation: <ul> <li>1 MB request size</li>
+         * <li>25 item limit per BatchDeleteAttributes operation</li> </ul> </p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/BatchDeleteAttributes">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::BatchDeleteAttributesOutcome BatchDeleteAttributes(const Model::BatchDeleteAttributesRequest& request) const;
+
+        /**
+         * <p> Performs multiple DeleteAttributes operations in a single call, which
+         * reduces round trips and latencies. This enables Amazon SimpleDB to optimize
+         * requests, which generally yields better throughput. </p> <p> The following
+         * limitations are enforced for this operation: <ul> <li>1 MB request size</li>
+         * <li>25 item limit per BatchDeleteAttributes operation</li> </ul> </p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/BatchDeleteAttributes">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::BatchDeleteAttributesOutcomeCallable BatchDeleteAttributesCallable(const Model::BatchDeleteAttributesRequest& request) const;
+
+        /**
+         * <p> Performs multiple DeleteAttributes operations in a single call, which
+         * reduces round trips and latencies. This enables Amazon SimpleDB to optimize
+         * requests, which generally yields better throughput. </p> <p> The following
+         * limitations are enforced for this operation: <ul> <li>1 MB request size</li>
+         * <li>25 item limit per BatchDeleteAttributes operation</li> </ul> </p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/BatchDeleteAttributes">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void BatchDeleteAttributesAsync(const Model::BatchDeleteAttributesRequest& request, const BatchDeleteAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p> The <code>BatchPutAttributes</code> operation creates or replaces attributes
+         * within one or more items. By using this operation, the client can perform
+         * multiple <a>PutAttribute</a> operation with a single call. This helps yield
+         * savings in round trips and latencies, enabling Amazon SimpleDB to optimize
+         * requests and generally produce better throughput. </p> <p> The client may
+         * specify the item name with the <code>Item.X.ItemName</code> parameter. The
+         * client may specify new attributes using a combination of the
+         * <code>Item.X.Attribute.Y.Name</code> and <code>Item.X.Attribute.Y.Value</code>
+         * parameters. The client may specify the first attribute for the first item using
+         * the parameters <code>Item.0.Attribute.0.Name</code> and
+         * <code>Item.0.Attribute.0.Value</code>, and for the second attribute for the
+         * first item by the parameters <code>Item.0.Attribute.1.Name</code> and
+         * <code>Item.0.Attribute.1.Value</code>, and so on. </p> <p> Attributes are
+         * uniquely identified within an item by their name/value combination. For example,
+         * a single item can have the attributes <code>{ "first_name", "first_value"
+         * }</code> and <code>{ "first_name", "second_value" }</code>. However, it cannot
+         * have two attribute instances where both the <code>Item.X.Attribute.Y.Name</code>
+         * and <code>Item.X.Attribute.Y.Value</code> are the same. </p> <p> Optionally, the
+         * requester can supply the <code>Replace</code> parameter for each individual
+         * value. Setting this value to <code>true</code> will cause the new attribute
+         * values to replace the existing attribute values. For example, if an item
+         * <code>I</code> has the attributes <code>{ 'a', '1' }, { 'b', '2'}</code> and
+         * <code>{ 'b', '3' }</code> and the requester does a BatchPutAttributes of
+         * <code>{'I', 'b', '4' }</code> with the Replace parameter set to true, the final
+         * attributes of the item will be <code>{ 'a', '1' }</code> and <code>{ 'b', '4'
+         * }</code>, replacing the previous values of the 'b' attribute with the new value.
+         * </p>  This operation is vulnerable to exceeding the maximum URL size
+         * when making a REST request using the HTTP GET method. This operation does not
+         * support conditions using <code>Expected.X.Name</code>,
+         * <code>Expected.X.Value</code>, or <code>Expected.X.Exists</code>. 
+         * <p> You can execute multiple <code>BatchPutAttributes</code> operations and
+         * other operations in parallel. However, large numbers of concurrent
+         * <code>BatchPutAttributes</code> calls can result in Service Unavailable (503)
+         * responses. </p> <p> The following limitations are enforced for this operation:
+         * <ul> <li>256 attribute name-value pairs per item</li> <li>1 MB request size</li>
+         * <li>1 billion attributes per domain</li> <li>10 GB of total user data storage
+         * per domain</li> <li>25 item limit per <code>BatchPutAttributes</code>
+         * operation</li> </ul> </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/BatchPutAttributes">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::BatchPutAttributesOutcome BatchPutAttributes(const Model::BatchPutAttributesRequest& request) const;
+
+        /**
+         * <p> The <code>BatchPutAttributes</code> operation creates or replaces attributes
+         * within one or more items. By using this operation, the client can perform
+         * multiple <a>PutAttribute</a> operation with a single call. This helps yield
+         * savings in round trips and latencies, enabling Amazon SimpleDB to optimize
+         * requests and generally produce better throughput. </p> <p> The client may
+         * specify the item name with the <code>Item.X.ItemName</code> parameter. The
+         * client may specify new attributes using a combination of the
+         * <code>Item.X.Attribute.Y.Name</code> and <code>Item.X.Attribute.Y.Value</code>
+         * parameters. The client may specify the first attribute for the first item using
+         * the parameters <code>Item.0.Attribute.0.Name</code> and
+         * <code>Item.0.Attribute.0.Value</code>, and for the second attribute for the
+         * first item by the parameters <code>Item.0.Attribute.1.Name</code> and
+         * <code>Item.0.Attribute.1.Value</code>, and so on. </p> <p> Attributes are
+         * uniquely identified within an item by their name/value combination. For example,
+         * a single item can have the attributes <code>{ "first_name", "first_value"
+         * }</code> and <code>{ "first_name", "second_value" }</code>. However, it cannot
+         * have two attribute instances where both the <code>Item.X.Attribute.Y.Name</code>
+         * and <code>Item.X.Attribute.Y.Value</code> are the same. </p> <p> Optionally, the
+         * requester can supply the <code>Replace</code> parameter for each individual
+         * value. Setting this value to <code>true</code> will cause the new attribute
+         * values to replace the existing attribute values. For example, if an item
+         * <code>I</code> has the attributes <code>{ 'a', '1' }, { 'b', '2'}</code> and
+         * <code>{ 'b', '3' }</code> and the requester does a BatchPutAttributes of
+         * <code>{'I', 'b', '4' }</code> with the Replace parameter set to true, the final
+         * attributes of the item will be <code>{ 'a', '1' }</code> and <code>{ 'b', '4'
+         * }</code>, replacing the previous values of the 'b' attribute with the new value.
+         * </p>  This operation is vulnerable to exceeding the maximum URL size
+         * when making a REST request using the HTTP GET method. This operation does not
+         * support conditions using <code>Expected.X.Name</code>,
+         * <code>Expected.X.Value</code>, or <code>Expected.X.Exists</code>. 
+         * <p> You can execute multiple <code>BatchPutAttributes</code> operations and
+         * other operations in parallel. However, large numbers of concurrent
+         * <code>BatchPutAttributes</code> calls can result in Service Unavailable (503)
+         * responses. </p> <p> The following limitations are enforced for this operation:
+         * <ul> <li>256 attribute name-value pairs per item</li> <li>1 MB request size</li>
+         * <li>1 billion attributes per domain</li> <li>10 GB of total user data storage
+         * per domain</li> <li>25 item limit per <code>BatchPutAttributes</code>
+         * operation</li> </ul> </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/BatchPutAttributes">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::BatchPutAttributesOutcomeCallable BatchPutAttributesCallable(const Model::BatchPutAttributesRequest& request) const;
+
+        /**
+         * <p> The <code>BatchPutAttributes</code> operation creates or replaces attributes
+         * within one or more items. By using this operation, the client can perform
+         * multiple <a>PutAttribute</a> operation with a single call. This helps yield
+         * savings in round trips and latencies, enabling Amazon SimpleDB to optimize
+         * requests and generally produce better throughput. </p> <p> The client may
+         * specify the item name with the <code>Item.X.ItemName</code> parameter. The
+         * client may specify new attributes using a combination of the
+         * <code>Item.X.Attribute.Y.Name</code> and <code>Item.X.Attribute.Y.Value</code>
+         * parameters. The client may specify the first attribute for the first item using
+         * the parameters <code>Item.0.Attribute.0.Name</code> and
+         * <code>Item.0.Attribute.0.Value</code>, and for the second attribute for the
+         * first item by the parameters <code>Item.0.Attribute.1.Name</code> and
+         * <code>Item.0.Attribute.1.Value</code>, and so on. </p> <p> Attributes are
+         * uniquely identified within an item by their name/value combination. For example,
+         * a single item can have the attributes <code>{ "first_name", "first_value"
+         * }</code> and <code>{ "first_name", "second_value" }</code>. However, it cannot
+         * have two attribute instances where both the <code>Item.X.Attribute.Y.Name</code>
+         * and <code>Item.X.Attribute.Y.Value</code> are the same. </p> <p> Optionally, the
+         * requester can supply the <code>Replace</code> parameter for each individual
+         * value. Setting this value to <code>true</code> will cause the new attribute
+         * values to replace the existing attribute values. For example, if an item
+         * <code>I</code> has the attributes <code>{ 'a', '1' }, { 'b', '2'}</code> and
+         * <code>{ 'b', '3' }</code> and the requester does a BatchPutAttributes of
+         * <code>{'I', 'b', '4' }</code> with the Replace parameter set to true, the final
+         * attributes of the item will be <code>{ 'a', '1' }</code> and <code>{ 'b', '4'
+         * }</code>, replacing the previous values of the 'b' attribute with the new value.
+         * </p>  This operation is vulnerable to exceeding the maximum URL size
+         * when making a REST request using the HTTP GET method. This operation does not
+         * support conditions using <code>Expected.X.Name</code>,
+         * <code>Expected.X.Value</code>, or <code>Expected.X.Exists</code>. 
+         * <p> You can execute multiple <code>BatchPutAttributes</code> operations and
+         * other operations in parallel. However, large numbers of concurrent
+         * <code>BatchPutAttributes</code> calls can result in Service Unavailable (503)
+         * responses. </p> <p> The following limitations are enforced for this operation:
+         * <ul> <li>256 attribute name-value pairs per item</li> <li>1 MB request size</li>
+         * <li>1 billion attributes per domain</li> <li>10 GB of total user data storage
+         * per domain</li> <li>25 item limit per <code>BatchPutAttributes</code>
+         * operation</li> </ul> </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/BatchPutAttributes">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void BatchPutAttributesAsync(const Model::BatchPutAttributesRequest& request, const BatchPutAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p> The <code>CreateDomain</code> operation creates a new domain. The domain
+         * name should be unique among the domains associated with the Access Key ID
+         * provided in the request. The <code>CreateDomain</code> operation may take 10 or
+         * more seconds to complete. </p> <p> The client can create up to 100 domains per
+         * account. </p> <p> If the client requires additional domains, go to <a
+         * href="http://aws.amazon.com/contact-us/simpledb-limit-request/">
+         * http://aws.amazon.com/contact-us/simpledb-limit-request/</a>. </p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/CreateDomain">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::CreateDomainOutcome CreateDomain(const Model::CreateDomainRequest& request) const;
+
+        /**
+         * <p> The <code>CreateDomain</code> operation creates a new domain. The domain
+         * name should be unique among the domains associated with the Access Key ID
+         * provided in the request. The <code>CreateDomain</code> operation may take 10 or
+         * more seconds to complete. </p> <p> The client can create up to 100 domains per
+         * account. </p> <p> If the client requires additional domains, go to <a
+         * href="http://aws.amazon.com/contact-us/simpledb-limit-request/">
+         * http://aws.amazon.com/contact-us/simpledb-limit-request/</a>. </p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/CreateDomain">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::CreateDomainOutcomeCallable CreateDomainCallable(const Model::CreateDomainRequest& request) const;
+
+        /**
+         * <p> The <code>CreateDomain</code> operation creates a new domain. The domain
+         * name should be unique among the domains associated with the Access Key ID
+         * provided in the request. The <code>CreateDomain</code> operation may take 10 or
+         * more seconds to complete. </p> <p> The client can create up to 100 domains per
+         * account. </p> <p> If the client requires additional domains, go to <a
+         * href="http://aws.amazon.com/contact-us/simpledb-limit-request/">
+         * http://aws.amazon.com/contact-us/simpledb-limit-request/</a>. </p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/CreateDomain">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void CreateDomainAsync(const Model::CreateDomainRequest& request, const CreateDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p> Deletes one or more attributes associated with an item. If all attributes of
+         * the item are deleted, the item is deleted. </p> <p>
+         * <code>DeleteAttributes</code> is an idempotent operation; running it multiple
+         * times on the same item or attribute does not result in an error response. </p>
+         * <p> Because Amazon SimpleDB makes multiple copies of item data and uses an
+         * eventual consistency update model, performing a <a>GetAttributes</a> or
+         * <a>Select</a> operation (read) immediately after a <code>DeleteAttributes</code>
+         * or <a>PutAttributes</a> operation (write) might not return updated item data.
+         * </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/DeleteAttributes">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DeleteAttributesOutcome DeleteAttributes(const Model::DeleteAttributesRequest& request) const;
+
+        /**
+         * <p> Deletes one or more attributes associated with an item. If all attributes of
+         * the item are deleted, the item is deleted. </p> <p>
+         * <code>DeleteAttributes</code> is an idempotent operation; running it multiple
+         * times on the same item or attribute does not result in an error response. </p>
+         * <p> Because Amazon SimpleDB makes multiple copies of item data and uses an
+         * eventual consistency update model, performing a <a>GetAttributes</a> or
+         * <a>Select</a> operation (read) immediately after a <code>DeleteAttributes</code>
+         * or <a>PutAttributes</a> operation (write) might not return updated item data.
+         * </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/DeleteAttributes">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DeleteAttributesOutcomeCallable DeleteAttributesCallable(const Model::DeleteAttributesRequest& request) const;
+
+        /**
+         * <p> Deletes one or more attributes associated with an item. If all attributes of
+         * the item are deleted, the item is deleted. </p> <p>
+         * <code>DeleteAttributes</code> is an idempotent operation; running it multiple
+         * times on the same item or attribute does not result in an error response. </p>
+         * <p> Because Amazon SimpleDB makes multiple copies of item data and uses an
+         * eventual consistency update model, performing a <a>GetAttributes</a> or
+         * <a>Select</a> operation (read) immediately after a <code>DeleteAttributes</code>
+         * or <a>PutAttributes</a> operation (write) might not return updated item data.
+         * </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/DeleteAttributes">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DeleteAttributesAsync(const Model::DeleteAttributesRequest& request, const DeleteAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p> The <code>DeleteDomain</code> operation deletes a domain. Any items (and
+         * their attributes) in the domain are deleted as well. The
+         * <code>DeleteDomain</code> operation might take 10 or more seconds to complete.
+         * </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/DeleteDomain">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DeleteDomainOutcome DeleteDomain(const Model::DeleteDomainRequest& request) const;
+
+        /**
+         * <p> The <code>DeleteDomain</code> operation deletes a domain. Any items (and
+         * their attributes) in the domain are deleted as well. The
+         * <code>DeleteDomain</code> operation might take 10 or more seconds to complete.
+         * </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/DeleteDomain">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DeleteDomainOutcomeCallable DeleteDomainCallable(const Model::DeleteDomainRequest& request) const;
+
+        /**
+         * <p> The <code>DeleteDomain</code> operation deletes a domain. Any items (and
+         * their attributes) in the domain are deleted as well. The
+         * <code>DeleteDomain</code> operation might take 10 or more seconds to complete.
+         * </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/DeleteDomain">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DeleteDomainAsync(const Model::DeleteDomainRequest& request, const DeleteDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p> Returns information about the domain, including when the domain was created,
+         * the number of items and attributes in the domain, and the size of the attribute
+         * names and values. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/DomainMetadata">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DomainMetadataOutcome DomainMetadata(const Model::DomainMetadataRequest& request) const;
+
+        /**
+         * <p> Returns information about the domain, including when the domain was created,
+         * the number of items and attributes in the domain, and the size of the attribute
+         * names and values. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/DomainMetadata">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DomainMetadataOutcomeCallable DomainMetadataCallable(const Model::DomainMetadataRequest& request) const;
+
+        /**
+         * <p> Returns information about the domain, including when the domain was created,
+         * the number of items and attributes in the domain, and the size of the attribute
+         * names and values. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/DomainMetadata">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DomainMetadataAsync(const Model::DomainMetadataRequest& request, const DomainMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p> Returns all of the attributes associated with the specified item.
+         * Optionally, the attributes returned can be limited to one or more attributes by
+         * specifying an attribute name parameter. </p> <p> If the item does not exist on
+         * the replica that was accessed for this operation, an empty set is returned. The
+         * system does not return an error as it cannot guarantee the item does not exist
+         * on other replicas. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/GetAttributes">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::GetAttributesOutcome GetAttributes(const Model::GetAttributesRequest& request) const;
+
+        /**
+         * <p> Returns all of the attributes associated with the specified item.
+         * Optionally, the attributes returned can be limited to one or more attributes by
+         * specifying an attribute name parameter. </p> <p> If the item does not exist on
+         * the replica that was accessed for this operation, an empty set is returned. The
+         * system does not return an error as it cannot guarantee the item does not exist
+         * on other replicas. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/GetAttributes">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::GetAttributesOutcomeCallable GetAttributesCallable(const Model::GetAttributesRequest& request) const;
+
+        /**
+         * <p> Returns all of the attributes associated with the specified item.
+         * Optionally, the attributes returned can be limited to one or more attributes by
+         * specifying an attribute name parameter. </p> <p> If the item does not exist on
+         * the replica that was accessed for this operation, an empty set is returned. The
+         * system does not return an error as it cannot guarantee the item does not exist
+         * on other replicas. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/GetAttributes">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void GetAttributesAsync(const Model::GetAttributesRequest& request, const GetAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p> The <code>ListDomains</code> operation lists all domains associated with the
+         * Access Key ID. It returns domain names up to the limit set by <a
+         * href="#MaxNumberOfDomains">MaxNumberOfDomains</a>. A <a
+         * href="#NextToken">NextToken</a> is returned if there are more than
+         * <code>MaxNumberOfDomains</code> domains. Calling <code>ListDomains</code>
+         * successive times with the <code>NextToken</code> provided by the operation
+         * returns up to <code>MaxNumberOfDomains</code> more domain names with each
+         * successive operation call. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/ListDomains">AWS API
+         * Reference</a></p>
+         */
+        virtual Model::ListDomainsOutcome ListDomains(const Model::ListDomainsRequest& request) const;
+
+        /**
+         * <p> The <code>ListDomains</code> operation lists all domains associated with the
+         * Access Key ID. It returns domain names up to the limit set by <a
+         * href="#MaxNumberOfDomains">MaxNumberOfDomains</a>. A <a
+         * href="#NextToken">NextToken</a> is returned if there are more than
+         * <code>MaxNumberOfDomains</code> domains. Calling <code>ListDomains</code>
+         * successive times with the <code>NextToken</code> provided by the operation
+         * returns up to <code>MaxNumberOfDomains</code> more domain names with each
+         * successive operation call. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/ListDomains">AWS API
+         * Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::ListDomainsOutcomeCallable ListDomainsCallable(const Model::ListDomainsRequest& request) const;
+
+        /**
+         * <p> The <code>ListDomains</code> operation lists all domains associated with the
+         * Access Key ID. It returns domain names up to the limit set by <a
+         * href="#MaxNumberOfDomains">MaxNumberOfDomains</a>. A <a
+         * href="#NextToken">NextToken</a> is returned if there are more than
+         * <code>MaxNumberOfDomains</code> domains. Calling <code>ListDomains</code>
+         * successive times with the <code>NextToken</code> provided by the operation
+         * returns up to <code>MaxNumberOfDomains</code> more domain names with each
+         * successive operation call. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/ListDomains">AWS API
+         * Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void ListDomainsAsync(const Model::ListDomainsRequest& request, const ListDomainsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p> The PutAttributes operation creates or replaces attributes in an item. The
+         * client may specify new attributes using a combination of the
+         * <code>Attribute.X.Name</code> and <code>Attribute.X.Value</code> parameters. The
+         * client specifies the first attribute by the parameters
+         * <code>Attribute.0.Name</code> and <code>Attribute.0.Value</code>, the second
+         * attribute by the parameters <code>Attribute.1.Name</code> and
+         * <code>Attribute.1.Value</code>, and so on. </p> <p> Attributes are uniquely
+         * identified in an item by their name/value combination. For example, a single
+         * item can have the attributes <code>{ "first_name", "first_value" }</code> and
+         * <code>{ "first_name", second_value" }</code>. However, it cannot have two
+         * attribute instances where both the <code>Attribute.X.Name</code> and
+         * <code>Attribute.X.Value</code> are the same. </p> <p> Optionally, the requestor
+         * can supply the <code>Replace</code> parameter for each individual attribute.
+         * Setting this value to <code>true</code> causes the new attribute value to
+         * replace the existing attribute value(s). For example, if an item has the
+         * attributes <code>{ 'a', '1' }</code>, <code>{ 'b', '2'}</code> and <code>{ 'b',
+         * '3' }</code> and the requestor calls <code>PutAttributes</code> using the
+         * attributes <code>{ 'b', '4' }</code> with the <code>Replace</code> parameter set
+         * to true, the final attributes of the item are changed to <code>{ 'a', '1'
+         * }</code> and <code>{ 'b', '4' }</code>, which replaces the previous values of
+         * the 'b' attribute with the new value. </p> <p> You cannot specify an empty
+         * string as an attribute name. </p> <p> Because Amazon SimpleDB makes multiple
+         * copies of client data and uses an eventual consistency update model, an
+         * immediate <a>GetAttributes</a> or <a>Select</a> operation (read) immediately
+         * after a <a>PutAttributes</a> or <a>DeleteAttributes</a> operation (write) might
+         * not return the updated data. </p> <p> The following limitations are enforced for
+         * this operation: <ul> <li>256 total attribute name-value pairs per item</li>
+         * <li>One billion attributes per domain</li> <li>10 GB of total user data storage
+         * per domain</li> </ul> </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/PutAttributes">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::PutAttributesOutcome PutAttributes(const Model::PutAttributesRequest& request) const;
+
+        /**
+         * <p> The PutAttributes operation creates or replaces attributes in an item. The
+         * client may specify new attributes using a combination of the
+         * <code>Attribute.X.Name</code> and <code>Attribute.X.Value</code> parameters. The
+         * client specifies the first attribute by the parameters
+         * <code>Attribute.0.Name</code> and <code>Attribute.0.Value</code>, the second
+         * attribute by the parameters <code>Attribute.1.Name</code> and
+         * <code>Attribute.1.Value</code>, and so on. </p> <p> Attributes are uniquely
+         * identified in an item by their name/value combination. For example, a single
+         * item can have the attributes <code>{ "first_name", "first_value" }</code> and
+         * <code>{ "first_name", second_value" }</code>. However, it cannot have two
+         * attribute instances where both the <code>Attribute.X.Name</code> and
+         * <code>Attribute.X.Value</code> are the same. </p> <p> Optionally, the requestor
+         * can supply the <code>Replace</code> parameter for each individual attribute.
+         * Setting this value to <code>true</code> causes the new attribute value to
+         * replace the existing attribute value(s). For example, if an item has the
+         * attributes <code>{ 'a', '1' }</code>, <code>{ 'b', '2'}</code> and <code>{ 'b',
+         * '3' }</code> and the requestor calls <code>PutAttributes</code> using the
+         * attributes <code>{ 'b', '4' }</code> with the <code>Replace</code> parameter set
+         * to true, the final attributes of the item are changed to <code>{ 'a', '1'
+         * }</code> and <code>{ 'b', '4' }</code>, which replaces the previous values of
+         * the 'b' attribute with the new value. </p> <p> You cannot specify an empty
+         * string as an attribute name. </p> <p> Because Amazon SimpleDB makes multiple
+         * copies of client data and uses an eventual consistency update model, an
+         * immediate <a>GetAttributes</a> or <a>Select</a> operation (read) immediately
+         * after a <a>PutAttributes</a> or <a>DeleteAttributes</a> operation (write) might
+         * not return the updated data. </p> <p> The following limitations are enforced for
+         * this operation: <ul> <li>256 total attribute name-value pairs per item</li>
+         * <li>One billion attributes per domain</li> <li>10 GB of total user data storage
+         * per domain</li> </ul> </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/PutAttributes">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::PutAttributesOutcomeCallable PutAttributesCallable(const Model::PutAttributesRequest& request) const;
+
+        /**
+         * <p> The PutAttributes operation creates or replaces attributes in an item. The
+         * client may specify new attributes using a combination of the
+         * <code>Attribute.X.Name</code> and <code>Attribute.X.Value</code> parameters. The
+         * client specifies the first attribute by the parameters
+         * <code>Attribute.0.Name</code> and <code>Attribute.0.Value</code>, the second
+         * attribute by the parameters <code>Attribute.1.Name</code> and
+         * <code>Attribute.1.Value</code>, and so on. </p> <p> Attributes are uniquely
+         * identified in an item by their name/value combination. For example, a single
+         * item can have the attributes <code>{ "first_name", "first_value" }</code> and
+         * <code>{ "first_name", second_value" }</code>. However, it cannot have two
+         * attribute instances where both the <code>Attribute.X.Name</code> and
+         * <code>Attribute.X.Value</code> are the same. </p> <p> Optionally, the requestor
+         * can supply the <code>Replace</code> parameter for each individual attribute.
+         * Setting this value to <code>true</code> causes the new attribute value to
+         * replace the existing attribute value(s). For example, if an item has the
+         * attributes <code>{ 'a', '1' }</code>, <code>{ 'b', '2'}</code> and <code>{ 'b',
+         * '3' }</code> and the requestor calls <code>PutAttributes</code> using the
+         * attributes <code>{ 'b', '4' }</code> with the <code>Replace</code> parameter set
+         * to true, the final attributes of the item are changed to <code>{ 'a', '1'
+         * }</code> and <code>{ 'b', '4' }</code>, which replaces the previous values of
+         * the 'b' attribute with the new value. </p> <p> You cannot specify an empty
+         * string as an attribute name. </p> <p> Because Amazon SimpleDB makes multiple
+         * copies of client data and uses an eventual consistency update model, an
+         * immediate <a>GetAttributes</a> or <a>Select</a> operation (read) immediately
+         * after a <a>PutAttributes</a> or <a>DeleteAttributes</a> operation (write) might
+         * not return the updated data. </p> <p> The following limitations are enforced for
+         * this operation: <ul> <li>256 total attribute name-value pairs per item</li>
+         * <li>One billion attributes per domain</li> <li>10 GB of total user data storage
+         * per domain</li> </ul> </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/PutAttributes">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void PutAttributesAsync(const Model::PutAttributesRequest& request, const PutAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p> The <code>Select</code> operation returns a set of attributes for
+         * <code>ItemNames</code> that match the select expression. <code>Select</code> is
+         * similar to the standard SQL SELECT statement. </p> <p> The total size of the
+         * response cannot exceed 1 MB in total size. Amazon SimpleDB automatically adjusts
+         * the number of items returned per page to enforce this limit. For example, if the
+         * client asks to retrieve 2500 items, but each individual item is 10 kB in size,
+         * the system returns 100 items and an appropriate <code>NextToken</code> so the
+         * client can access the next page of results. </p> <p> For information on how to
+         * construct select expressions, see Using Select to Create Amazon SimpleDB Queries
+         * in the Developer Guide. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/Select">AWS API
+         * Reference</a></p>
+         */
+        virtual Model::SelectOutcome Select(const Model::SelectRequest& request) const;
+
+        /**
+         * <p> The <code>Select</code> operation returns a set of attributes for
+         * <code>ItemNames</code> that match the select expression. <code>Select</code> is
+         * similar to the standard SQL SELECT statement. </p> <p> The total size of the
+         * response cannot exceed 1 MB in total size. Amazon SimpleDB automatically adjusts
+         * the number of items returned per page to enforce this limit. For example, if the
+         * client asks to retrieve 2500 items, but each individual item is 10 kB in size,
+         * the system returns 100 items and an appropriate <code>NextToken</code> so the
+         * client can access the next page of results. </p> <p> For information on how to
+         * construct select expressions, see Using Select to Create Amazon SimpleDB Queries
+         * in the Developer Guide. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/Select">AWS API
+         * Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::SelectOutcomeCallable SelectCallable(const Model::SelectRequest& request) const;
+
+        /**
+         * <p> The <code>Select</code> operation returns a set of attributes for
+         * <code>ItemNames</code> that match the select expression. <code>Select</code> is
+         * similar to the standard SQL SELECT statement. </p> <p> The total size of the
+         * response cannot exceed 1 MB in total size. Amazon SimpleDB automatically adjusts
+         * the number of items returned per page to enforce this limit. For example, if the
+         * client asks to retrieve 2500 items, but each individual item is 10 kB in size,
+         * the system returns 100 items and an appropriate <code>NextToken</code> so the
+         * client can access the next page of results. </p> <p> For information on how to
+         * construct select expressions, see Using Select to Create Amazon SimpleDB Queries
+         * in the Developer Guide. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/Select">AWS API
+         * Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void SelectAsync(const Model::SelectRequest& request, const SelectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+
+        void OverrideEndpoint(const Aws::String& endpoint);
+  private:
+        void init(const Aws::Client::ClientConfiguration& clientConfiguration);
+        void BatchDeleteAttributesAsyncHelper(const Model::BatchDeleteAttributesRequest& request, const BatchDeleteAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void BatchPutAttributesAsyncHelper(const Model::BatchPutAttributesRequest& request, const BatchPutAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void CreateDomainAsyncHelper(const Model::CreateDomainRequest& request, const CreateDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DeleteAttributesAsyncHelper(const Model::DeleteAttributesRequest& request, const DeleteAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DeleteDomainAsyncHelper(const Model::DeleteDomainRequest& request, const DeleteDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DomainMetadataAsyncHelper(const Model::DomainMetadataRequest& request, const DomainMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void GetAttributesAsyncHelper(const Model::GetAttributesRequest& request, const GetAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void ListDomainsAsyncHelper(const Model::ListDomainsRequest& request, const ListDomainsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void PutAttributesAsyncHelper(const Model::PutAttributesRequest& request, const PutAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void SelectAsyncHelper(const Model::SelectRequest& request, const SelectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+
+        Aws::String m_uri;
+        Aws::String m_configScheme;
+        std::shared_ptr<Aws::Utils::Threading::Executor> m_executor;
+  };
+
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/SimpleDBEndpoint.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/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/Region.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+
+namespace SimpleDB
+{
+namespace SimpleDBEndpoint
+{
+AWS_SIMPLEDB_API Aws::String ForRegion(const Aws::String& regionName, bool useDualStack = false);
+} // namespace SimpleDBEndpoint
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/SimpleDBErrorMarshaller.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/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/client/AWSErrorMarshaller.h>
+
+namespace Aws
+{
+namespace Client
+{
+
+class AWS_SIMPLEDB_API SimpleDBErrorMarshaller : public Aws::Client::XmlErrorMarshaller
+{
+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-sdb/include/aws/sdb/SimpleDBErrors.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/core/client/AWSError.h>
+#include <aws/core/client/CoreErrors.h>
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+
+namespace Aws
+{
+namespace SimpleDB
+{
+enum class SimpleDBErrors
+{
+  //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,
+  ///////////////////////////////////////////////////////////////////////////////////////////
+
+  ATTRIBUTE_DOES_NOT_EXIST= static_cast<int>(Aws::Client::CoreErrors::SERVICE_EXTENSION_START_RANGE) + 1,
+  DUPLICATE_ITEM_NAME,
+  INVALID_NEXT_TOKEN,
+  INVALID_NUMBER_PREDICATES,
+  INVALID_NUMBER_VALUE_TESTS,
+  INVALID_QUERY_EXPRESSION,
+  NO_SUCH_DOMAIN,
+  NUMBER_DOMAINS_EXCEEDED,
+  NUMBER_DOMAIN_ATTRIBUTES_EXCEEDED,
+  NUMBER_DOMAIN_BYTES_EXCEEDED,
+  NUMBER_ITEM_ATTRIBUTES_EXCEEDED,
+  NUMBER_SUBMITTED_ATTRIBUTES_EXCEEDED,
+  NUMBER_SUBMITTED_ITEMS_EXCEEDED,
+  TOO_MANY_REQUESTED_ATTRIBUTES
+};
+
+class AWS_SIMPLEDB_API SimpleDBError : public Aws::Client::AWSError<SimpleDBErrors>
+{
+public:
+  SimpleDBError() {}
+  SimpleDBError(const Aws::Client::AWSError<Aws::Client::CoreErrors>& rhs) : Aws::Client::AWSError<SimpleDBErrors>(rhs) {}
+  SimpleDBError(Aws::Client::AWSError<Aws::Client::CoreErrors>&& rhs) : Aws::Client::AWSError<SimpleDBErrors>(rhs) {}
+  SimpleDBError(const Aws::Client::AWSError<SimpleDBErrors>& rhs) : Aws::Client::AWSError<SimpleDBErrors>(rhs) {}
+  SimpleDBError(Aws::Client::AWSError<SimpleDBErrors>&& rhs) : Aws::Client::AWSError<SimpleDBErrors>(rhs) {}
+
+  template <typename T>
+  T GetModeledError();
+};
+
+namespace SimpleDBErrorMapper
+{
+  AWS_SIMPLEDB_API Aws::Client::AWSError<Aws::Client::CoreErrors> GetErrorForName(const char* errorName);
+}
+
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/SimpleDBRequest.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/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/AmazonSerializableWebServiceRequest.h>
+#include <aws/core/utils/UnreferencedParam.h>
+#include <aws/core/http/HttpRequest.h>
+
+namespace Aws
+{
+namespace SimpleDB
+{
+  class AWS_SIMPLEDB_API SimpleDBRequest : public Aws::AmazonSerializableWebServiceRequest
+  {
+  public:
+    virtual ~SimpleDBRequest () {}
+
+    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::FORM_CONTENT_TYPE ));
+      }
+      headers.emplace(Aws::Http::HeaderValuePair(Aws::Http::API_VERSION_HEADER, "2009-04-15"));
+      return headers;
+    }
+
+  protected:
+    virtual Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const { return Aws::Http::HeaderValueCollection(); }
+
+  };
+
+
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/SimpleDB_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_SIMPLEDB_EXPORTS
+            #define AWS_SIMPLEDB_API __declspec(dllexport)
+        #else
+            #define AWS_SIMPLEDB_API __declspec(dllimport)
+        #endif /* AWS_SIMPLEDB_EXPORTS */
+    #else
+        #define AWS_SIMPLEDB_API
+    #endif // USE_IMPORT_EXPORT
+#else // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)
+    #define AWS_SIMPLEDB_API
+#endif // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/Attribute.h

@@ -0,0 +1,222 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   * <p></p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/Attribute">AWS API
+   * Reference</a></p>
+   */
+  class AWS_SIMPLEDB_API Attribute
+  {
+  public:
+    Attribute();
+    Attribute(const Aws::Utils::Xml::XmlNode& xmlNode);
+    Attribute& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    /**
+     * The name of the attribute.
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * The name of the attribute.
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * The name of the attribute.
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * The name of the attribute.
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * The name of the attribute.
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * The name of the attribute.
+     */
+    inline Attribute& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * The name of the attribute.
+     */
+    inline Attribute& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * The name of the attribute.
+     */
+    inline Attribute& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * <p></p>
+     */
+    inline const Aws::String& GetAlternateNameEncoding() const{ return m_alternateNameEncoding; }
+
+    /**
+     * <p></p>
+     */
+    inline bool AlternateNameEncodingHasBeenSet() const { return m_alternateNameEncodingHasBeenSet; }
+
+    /**
+     * <p></p>
+     */
+    inline void SetAlternateNameEncoding(const Aws::String& value) { m_alternateNameEncodingHasBeenSet = true; m_alternateNameEncoding = value; }
+
+    /**
+     * <p></p>
+     */
+    inline void SetAlternateNameEncoding(Aws::String&& value) { m_alternateNameEncodingHasBeenSet = true; m_alternateNameEncoding = std::move(value); }
+
+    /**
+     * <p></p>
+     */
+    inline void SetAlternateNameEncoding(const char* value) { m_alternateNameEncodingHasBeenSet = true; m_alternateNameEncoding.assign(value); }
+
+    /**
+     * <p></p>
+     */
+    inline Attribute& WithAlternateNameEncoding(const Aws::String& value) { SetAlternateNameEncoding(value); return *this;}
+
+    /**
+     * <p></p>
+     */
+    inline Attribute& WithAlternateNameEncoding(Aws::String&& value) { SetAlternateNameEncoding(std::move(value)); return *this;}
+
+    /**
+     * <p></p>
+     */
+    inline Attribute& WithAlternateNameEncoding(const char* value) { SetAlternateNameEncoding(value); return *this;}
+
+
+    /**
+     * The value of the attribute.
+     */
+    inline const Aws::String& GetValue() const{ return m_value; }
+
+    /**
+     * The value of the attribute.
+     */
+    inline bool ValueHasBeenSet() const { return m_valueHasBeenSet; }
+
+    /**
+     * The value of the attribute.
+     */
+    inline void SetValue(const Aws::String& value) { m_valueHasBeenSet = true; m_value = value; }
+
+    /**
+     * The value of the attribute.
+     */
+    inline void SetValue(Aws::String&& value) { m_valueHasBeenSet = true; m_value = std::move(value); }
+
+    /**
+     * The value of the attribute.
+     */
+    inline void SetValue(const char* value) { m_valueHasBeenSet = true; m_value.assign(value); }
+
+    /**
+     * The value of the attribute.
+     */
+    inline Attribute& WithValue(const Aws::String& value) { SetValue(value); return *this;}
+
+    /**
+     * The value of the attribute.
+     */
+    inline Attribute& WithValue(Aws::String&& value) { SetValue(std::move(value)); return *this;}
+
+    /**
+     * The value of the attribute.
+     */
+    inline Attribute& WithValue(const char* value) { SetValue(value); return *this;}
+
+
+    /**
+     * <p></p>
+     */
+    inline const Aws::String& GetAlternateValueEncoding() const{ return m_alternateValueEncoding; }
+
+    /**
+     * <p></p>
+     */
+    inline bool AlternateValueEncodingHasBeenSet() const { return m_alternateValueEncodingHasBeenSet; }
+
+    /**
+     * <p></p>
+     */
+    inline void SetAlternateValueEncoding(const Aws::String& value) { m_alternateValueEncodingHasBeenSet = true; m_alternateValueEncoding = value; }
+
+    /**
+     * <p></p>
+     */
+    inline void SetAlternateValueEncoding(Aws::String&& value) { m_alternateValueEncodingHasBeenSet = true; m_alternateValueEncoding = std::move(value); }
+
+    /**
+     * <p></p>
+     */
+    inline void SetAlternateValueEncoding(const char* value) { m_alternateValueEncodingHasBeenSet = true; m_alternateValueEncoding.assign(value); }
+
+    /**
+     * <p></p>
+     */
+    inline Attribute& WithAlternateValueEncoding(const Aws::String& value) { SetAlternateValueEncoding(value); return *this;}
+
+    /**
+     * <p></p>
+     */
+    inline Attribute& WithAlternateValueEncoding(Aws::String&& value) { SetAlternateValueEncoding(std::move(value)); return *this;}
+
+    /**
+     * <p></p>
+     */
+    inline Attribute& WithAlternateValueEncoding(const char* value) { SetAlternateValueEncoding(value); return *this;}
+
+  private:
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    Aws::String m_alternateNameEncoding;
+    bool m_alternateNameEncodingHasBeenSet;
+
+    Aws::String m_value;
+    bool m_valueHasBeenSet;
+
+    Aws::String m_alternateValueEncoding;
+    bool m_alternateValueEncodingHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/AttributeDoesNotExist.h

@@ -0,0 +1,60 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   * <p>The specified attribute does not exist.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/AttributeDoesNotExist">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SIMPLEDB_API AttributeDoesNotExist
+  {
+  public:
+    AttributeDoesNotExist();
+    AttributeDoesNotExist(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AttributeDoesNotExist& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    
+    inline double GetBoxUsage() const{ return m_boxUsage; }
+
+    
+    inline bool BoxUsageHasBeenSet() const { return m_boxUsageHasBeenSet; }
+
+    
+    inline void SetBoxUsage(double value) { m_boxUsageHasBeenSet = true; m_boxUsage = value; }
+
+    
+    inline AttributeDoesNotExist& WithBoxUsage(double value) { SetBoxUsage(value); return *this;}
+
+  private:
+
+    double m_boxUsage;
+    bool m_boxUsageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/BatchDeleteAttributesRequest.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/sdb/SimpleDB_EXPORTS.h>
+#include <aws/sdb/SimpleDBRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/sdb/model/DeletableItem.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SIMPLEDB_API BatchDeleteAttributesRequest : public SimpleDBRequest
+  {
+  public:
+    BatchDeleteAttributesRequest();
+
+    // 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 "BatchDeleteAttributes"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * The name of the domain in which the attributes are being deleted.
+     */
+    inline const Aws::String& GetDomainName() const{ return m_domainName; }
+
+    /**
+     * The name of the domain in which the attributes are being deleted.
+     */
+    inline bool DomainNameHasBeenSet() const { return m_domainNameHasBeenSet; }
+
+    /**
+     * The name of the domain in which the attributes are being deleted.
+     */
+    inline void SetDomainName(const Aws::String& value) { m_domainNameHasBeenSet = true; m_domainName = value; }
+
+    /**
+     * The name of the domain in which the attributes are being deleted.
+     */
+    inline void SetDomainName(Aws::String&& value) { m_domainNameHasBeenSet = true; m_domainName = std::move(value); }
+
+    /**
+     * The name of the domain in which the attributes are being deleted.
+     */
+    inline void SetDomainName(const char* value) { m_domainNameHasBeenSet = true; m_domainName.assign(value); }
+
+    /**
+     * The name of the domain in which the attributes are being deleted.
+     */
+    inline BatchDeleteAttributesRequest& WithDomainName(const Aws::String& value) { SetDomainName(value); return *this;}
+
+    /**
+     * The name of the domain in which the attributes are being deleted.
+     */
+    inline BatchDeleteAttributesRequest& WithDomainName(Aws::String&& value) { SetDomainName(std::move(value)); return *this;}
+
+    /**
+     * The name of the domain in which the attributes are being deleted.
+     */
+    inline BatchDeleteAttributesRequest& WithDomainName(const char* value) { SetDomainName(value); return *this;}
+
+
+    /**
+     * A list of items on which to perform the operation.
+     */
+    inline const Aws::Vector<DeletableItem>& GetItems() const{ return m_items; }
+
+    /**
+     * A list of items on which to perform the operation.
+     */
+    inline bool ItemsHasBeenSet() const { return m_itemsHasBeenSet; }
+
+    /**
+     * A list of items on which to perform the operation.
+     */
+    inline void SetItems(const Aws::Vector<DeletableItem>& value) { m_itemsHasBeenSet = true; m_items = value; }
+
+    /**
+     * A list of items on which to perform the operation.
+     */
+    inline void SetItems(Aws::Vector<DeletableItem>&& value) { m_itemsHasBeenSet = true; m_items = std::move(value); }
+
+    /**
+     * A list of items on which to perform the operation.
+     */
+    inline BatchDeleteAttributesRequest& WithItems(const Aws::Vector<DeletableItem>& value) { SetItems(value); return *this;}
+
+    /**
+     * A list of items on which to perform the operation.
+     */
+    inline BatchDeleteAttributesRequest& WithItems(Aws::Vector<DeletableItem>&& value) { SetItems(std::move(value)); return *this;}
+
+    /**
+     * A list of items on which to perform the operation.
+     */
+    inline BatchDeleteAttributesRequest& AddItems(const DeletableItem& value) { m_itemsHasBeenSet = true; m_items.push_back(value); return *this; }
+
+    /**
+     * A list of items on which to perform the operation.
+     */
+    inline BatchDeleteAttributesRequest& AddItems(DeletableItem&& value) { m_itemsHasBeenSet = true; m_items.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_domainName;
+    bool m_domainNameHasBeenSet;
+
+    Aws::Vector<DeletableItem> m_items;
+    bool m_itemsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/BatchPutAttributesRequest.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/sdb/SimpleDB_EXPORTS.h>
+#include <aws/sdb/SimpleDBRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/sdb/model/ReplaceableItem.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SIMPLEDB_API BatchPutAttributesRequest : public SimpleDBRequest
+  {
+  public:
+    BatchPutAttributesRequest();
+
+    // 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 "BatchPutAttributes"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * The name of the domain in which the attributes are being stored.
+     */
+    inline const Aws::String& GetDomainName() const{ return m_domainName; }
+
+    /**
+     * The name of the domain in which the attributes are being stored.
+     */
+    inline bool DomainNameHasBeenSet() const { return m_domainNameHasBeenSet; }
+
+    /**
+     * The name of the domain in which the attributes are being stored.
+     */
+    inline void SetDomainName(const Aws::String& value) { m_domainNameHasBeenSet = true; m_domainName = value; }
+
+    /**
+     * The name of the domain in which the attributes are being stored.
+     */
+    inline void SetDomainName(Aws::String&& value) { m_domainNameHasBeenSet = true; m_domainName = std::move(value); }
+
+    /**
+     * The name of the domain in which the attributes are being stored.
+     */
+    inline void SetDomainName(const char* value) { m_domainNameHasBeenSet = true; m_domainName.assign(value); }
+
+    /**
+     * The name of the domain in which the attributes are being stored.
+     */
+    inline BatchPutAttributesRequest& WithDomainName(const Aws::String& value) { SetDomainName(value); return *this;}
+
+    /**
+     * The name of the domain in which the attributes are being stored.
+     */
+    inline BatchPutAttributesRequest& WithDomainName(Aws::String&& value) { SetDomainName(std::move(value)); return *this;}
+
+    /**
+     * The name of the domain in which the attributes are being stored.
+     */
+    inline BatchPutAttributesRequest& WithDomainName(const char* value) { SetDomainName(value); return *this;}
+
+
+    /**
+     * A list of items on which to perform the operation.
+     */
+    inline const Aws::Vector<ReplaceableItem>& GetItems() const{ return m_items; }
+
+    /**
+     * A list of items on which to perform the operation.
+     */
+    inline bool ItemsHasBeenSet() const { return m_itemsHasBeenSet; }
+
+    /**
+     * A list of items on which to perform the operation.
+     */
+    inline void SetItems(const Aws::Vector<ReplaceableItem>& value) { m_itemsHasBeenSet = true; m_items = value; }
+
+    /**
+     * A list of items on which to perform the operation.
+     */
+    inline void SetItems(Aws::Vector<ReplaceableItem>&& value) { m_itemsHasBeenSet = true; m_items = std::move(value); }
+
+    /**
+     * A list of items on which to perform the operation.
+     */
+    inline BatchPutAttributesRequest& WithItems(const Aws::Vector<ReplaceableItem>& value) { SetItems(value); return *this;}
+
+    /**
+     * A list of items on which to perform the operation.
+     */
+    inline BatchPutAttributesRequest& WithItems(Aws::Vector<ReplaceableItem>&& value) { SetItems(std::move(value)); return *this;}
+
+    /**
+     * A list of items on which to perform the operation.
+     */
+    inline BatchPutAttributesRequest& AddItems(const ReplaceableItem& value) { m_itemsHasBeenSet = true; m_items.push_back(value); return *this; }
+
+    /**
+     * A list of items on which to perform the operation.
+     */
+    inline BatchPutAttributesRequest& AddItems(ReplaceableItem&& value) { m_itemsHasBeenSet = true; m_items.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_domainName;
+    bool m_domainNameHasBeenSet;
+
+    Aws::Vector<ReplaceableItem> m_items;
+    bool m_itemsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/CreateDomainRequest.h

@@ -0,0 +1,103 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/sdb/SimpleDBRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SIMPLEDB_API CreateDomainRequest : public SimpleDBRequest
+  {
+  public:
+    CreateDomainRequest();
+
+    // 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 "CreateDomain"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * The name of the domain to create. The name can range between 3 and 255
+     * characters and can contain the following characters: a-z, A-Z, 0-9, '_', '-',
+     * and '.'.
+     */
+    inline const Aws::String& GetDomainName() const{ return m_domainName; }
+
+    /**
+     * The name of the domain to create. The name can range between 3 and 255
+     * characters and can contain the following characters: a-z, A-Z, 0-9, '_', '-',
+     * and '.'.
+     */
+    inline bool DomainNameHasBeenSet() const { return m_domainNameHasBeenSet; }
+
+    /**
+     * The name of the domain to create. The name can range between 3 and 255
+     * characters and can contain the following characters: a-z, A-Z, 0-9, '_', '-',
+     * and '.'.
+     */
+    inline void SetDomainName(const Aws::String& value) { m_domainNameHasBeenSet = true; m_domainName = value; }
+
+    /**
+     * The name of the domain to create. The name can range between 3 and 255
+     * characters and can contain the following characters: a-z, A-Z, 0-9, '_', '-',
+     * and '.'.
+     */
+    inline void SetDomainName(Aws::String&& value) { m_domainNameHasBeenSet = true; m_domainName = std::move(value); }
+
+    /**
+     * The name of the domain to create. The name can range between 3 and 255
+     * characters and can contain the following characters: a-z, A-Z, 0-9, '_', '-',
+     * and '.'.
+     */
+    inline void SetDomainName(const char* value) { m_domainNameHasBeenSet = true; m_domainName.assign(value); }
+
+    /**
+     * The name of the domain to create. The name can range between 3 and 255
+     * characters and can contain the following characters: a-z, A-Z, 0-9, '_', '-',
+     * and '.'.
+     */
+    inline CreateDomainRequest& WithDomainName(const Aws::String& value) { SetDomainName(value); return *this;}
+
+    /**
+     * The name of the domain to create. The name can range between 3 and 255
+     * characters and can contain the following characters: a-z, A-Z, 0-9, '_', '-',
+     * and '.'.
+     */
+    inline CreateDomainRequest& WithDomainName(Aws::String&& value) { SetDomainName(std::move(value)); return *this;}
+
+    /**
+     * The name of the domain to create. The name can range between 3 and 255
+     * characters and can contain the following characters: a-z, A-Z, 0-9, '_', '-',
+     * and '.'.
+     */
+    inline CreateDomainRequest& WithDomainName(const char* value) { SetDomainName(value); return *this;}
+
+  private:
+
+    Aws::String m_domainName;
+    bool m_domainNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/DeletableItem.h

@@ -0,0 +1,99 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/sdb/model/Attribute.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace SimpleDB
+{
+namespace Model
+{
+
+  class AWS_SIMPLEDB_API DeletableItem
+  {
+  public:
+    DeletableItem();
+    DeletableItem(const Aws::Utils::Xml::XmlNode& xmlNode);
+    DeletableItem& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    
+    inline DeletableItem& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    
+    inline DeletableItem& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    
+    inline DeletableItem& WithName(const char* value) { SetName(value); return *this;}
+
+
+    
+    inline const Aws::Vector<Attribute>& GetAttributes() const{ return m_attributes; }
+
+    
+    inline bool AttributesHasBeenSet() const { return m_attributesHasBeenSet; }
+
+    
+    inline void SetAttributes(const Aws::Vector<Attribute>& value) { m_attributesHasBeenSet = true; m_attributes = value; }
+
+    
+    inline void SetAttributes(Aws::Vector<Attribute>&& value) { m_attributesHasBeenSet = true; m_attributes = std::move(value); }
+
+    
+    inline DeletableItem& WithAttributes(const Aws::Vector<Attribute>& value) { SetAttributes(value); return *this;}
+
+    
+    inline DeletableItem& WithAttributes(Aws::Vector<Attribute>&& value) { SetAttributes(std::move(value)); return *this;}
+
+    
+    inline DeletableItem& AddAttributes(const Attribute& value) { m_attributesHasBeenSet = true; m_attributes.push_back(value); return *this; }
+
+    
+    inline DeletableItem& AddAttributes(Attribute&& value) { m_attributesHasBeenSet = true; m_attributes.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    Aws::Vector<Attribute> m_attributes;
+    bool m_attributesHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/DeleteAttributesRequest.h

@@ -0,0 +1,240 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/sdb/SimpleDBRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/sdb/model/UpdateCondition.h>
+#include <aws/sdb/model/Attribute.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SIMPLEDB_API DeleteAttributesRequest : public SimpleDBRequest
+  {
+  public:
+    DeleteAttributesRequest();
+
+    // 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 "DeleteAttributes"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * The name of the domain in which to perform the operation.
+     */
+    inline const Aws::String& GetDomainName() const{ return m_domainName; }
+
+    /**
+     * The name of the domain in which to perform the operation.
+     */
+    inline bool DomainNameHasBeenSet() const { return m_domainNameHasBeenSet; }
+
+    /**
+     * The name of the domain in which to perform the operation.
+     */
+    inline void SetDomainName(const Aws::String& value) { m_domainNameHasBeenSet = true; m_domainName = value; }
+
+    /**
+     * The name of the domain in which to perform the operation.
+     */
+    inline void SetDomainName(Aws::String&& value) { m_domainNameHasBeenSet = true; m_domainName = std::move(value); }
+
+    /**
+     * The name of the domain in which to perform the operation.
+     */
+    inline void SetDomainName(const char* value) { m_domainNameHasBeenSet = true; m_domainName.assign(value); }
+
+    /**
+     * The name of the domain in which to perform the operation.
+     */
+    inline DeleteAttributesRequest& WithDomainName(const Aws::String& value) { SetDomainName(value); return *this;}
+
+    /**
+     * The name of the domain in which to perform the operation.
+     */
+    inline DeleteAttributesRequest& WithDomainName(Aws::String&& value) { SetDomainName(std::move(value)); return *this;}
+
+    /**
+     * The name of the domain in which to perform the operation.
+     */
+    inline DeleteAttributesRequest& WithDomainName(const char* value) { SetDomainName(value); return *this;}
+
+
+    /**
+     * The name of the item. Similar to rows on a spreadsheet, items represent
+     * individual objects that contain one or more value-attribute pairs.
+     */
+    inline const Aws::String& GetItemName() const{ return m_itemName; }
+
+    /**
+     * The name of the item. Similar to rows on a spreadsheet, items represent
+     * individual objects that contain one or more value-attribute pairs.
+     */
+    inline bool ItemNameHasBeenSet() const { return m_itemNameHasBeenSet; }
+
+    /**
+     * The name of the item. Similar to rows on a spreadsheet, items represent
+     * individual objects that contain one or more value-attribute pairs.
+     */
+    inline void SetItemName(const Aws::String& value) { m_itemNameHasBeenSet = true; m_itemName = value; }
+
+    /**
+     * The name of the item. Similar to rows on a spreadsheet, items represent
+     * individual objects that contain one or more value-attribute pairs.
+     */
+    inline void SetItemName(Aws::String&& value) { m_itemNameHasBeenSet = true; m_itemName = std::move(value); }
+
+    /**
+     * The name of the item. Similar to rows on a spreadsheet, items represent
+     * individual objects that contain one or more value-attribute pairs.
+     */
+    inline void SetItemName(const char* value) { m_itemNameHasBeenSet = true; m_itemName.assign(value); }
+
+    /**
+     * The name of the item. Similar to rows on a spreadsheet, items represent
+     * individual objects that contain one or more value-attribute pairs.
+     */
+    inline DeleteAttributesRequest& WithItemName(const Aws::String& value) { SetItemName(value); return *this;}
+
+    /**
+     * The name of the item. Similar to rows on a spreadsheet, items represent
+     * individual objects that contain one or more value-attribute pairs.
+     */
+    inline DeleteAttributesRequest& WithItemName(Aws::String&& value) { SetItemName(std::move(value)); return *this;}
+
+    /**
+     * The name of the item. Similar to rows on a spreadsheet, items represent
+     * individual objects that contain one or more value-attribute pairs.
+     */
+    inline DeleteAttributesRequest& WithItemName(const char* value) { SetItemName(value); return *this;}
+
+
+    /**
+     * A list of Attributes. Similar to columns on a spreadsheet, attributes represent
+     * categories of data that can be assigned to items.
+     */
+    inline const Aws::Vector<Attribute>& GetAttributes() const{ return m_attributes; }
+
+    /**
+     * A list of Attributes. Similar to columns on a spreadsheet, attributes represent
+     * categories of data that can be assigned to items.
+     */
+    inline bool AttributesHasBeenSet() const { return m_attributesHasBeenSet; }
+
+    /**
+     * A list of Attributes. Similar to columns on a spreadsheet, attributes represent
+     * categories of data that can be assigned to items.
+     */
+    inline void SetAttributes(const Aws::Vector<Attribute>& value) { m_attributesHasBeenSet = true; m_attributes = value; }
+
+    /**
+     * A list of Attributes. Similar to columns on a spreadsheet, attributes represent
+     * categories of data that can be assigned to items.
+     */
+    inline void SetAttributes(Aws::Vector<Attribute>&& value) { m_attributesHasBeenSet = true; m_attributes = std::move(value); }
+
+    /**
+     * A list of Attributes. Similar to columns on a spreadsheet, attributes represent
+     * categories of data that can be assigned to items.
+     */
+    inline DeleteAttributesRequest& WithAttributes(const Aws::Vector<Attribute>& value) { SetAttributes(value); return *this;}
+
+    /**
+     * A list of Attributes. Similar to columns on a spreadsheet, attributes represent
+     * categories of data that can be assigned to items.
+     */
+    inline DeleteAttributesRequest& WithAttributes(Aws::Vector<Attribute>&& value) { SetAttributes(std::move(value)); return *this;}
+
+    /**
+     * A list of Attributes. Similar to columns on a spreadsheet, attributes represent
+     * categories of data that can be assigned to items.
+     */
+    inline DeleteAttributesRequest& AddAttributes(const Attribute& value) { m_attributesHasBeenSet = true; m_attributes.push_back(value); return *this; }
+
+    /**
+     * A list of Attributes. Similar to columns on a spreadsheet, attributes represent
+     * categories of data that can be assigned to items.
+     */
+    inline DeleteAttributesRequest& AddAttributes(Attribute&& value) { m_attributesHasBeenSet = true; m_attributes.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * The update condition which, if specified, determines whether the specified
+     * attributes will be deleted or not. The update condition must be satisfied in
+     * order for this request to be processed and the attributes to be deleted.
+     */
+    inline const UpdateCondition& GetExpected() const{ return m_expected; }
+
+    /**
+     * The update condition which, if specified, determines whether the specified
+     * attributes will be deleted or not. The update condition must be satisfied in
+     * order for this request to be processed and the attributes to be deleted.
+     */
+    inline bool ExpectedHasBeenSet() const { return m_expectedHasBeenSet; }
+
+    /**
+     * The update condition which, if specified, determines whether the specified
+     * attributes will be deleted or not. The update condition must be satisfied in
+     * order for this request to be processed and the attributes to be deleted.
+     */
+    inline void SetExpected(const UpdateCondition& value) { m_expectedHasBeenSet = true; m_expected = value; }
+
+    /**
+     * The update condition which, if specified, determines whether the specified
+     * attributes will be deleted or not. The update condition must be satisfied in
+     * order for this request to be processed and the attributes to be deleted.
+     */
+    inline void SetExpected(UpdateCondition&& value) { m_expectedHasBeenSet = true; m_expected = std::move(value); }
+
+    /**
+     * The update condition which, if specified, determines whether the specified
+     * attributes will be deleted or not. The update condition must be satisfied in
+     * order for this request to be processed and the attributes to be deleted.
+     */
+    inline DeleteAttributesRequest& WithExpected(const UpdateCondition& value) { SetExpected(value); return *this;}
+
+    /**
+     * The update condition which, if specified, determines whether the specified
+     * attributes will be deleted or not. The update condition must be satisfied in
+     * order for this request to be processed and the attributes to be deleted.
+     */
+    inline DeleteAttributesRequest& WithExpected(UpdateCondition&& value) { SetExpected(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_domainName;
+    bool m_domainNameHasBeenSet;
+
+    Aws::String m_itemName;
+    bool m_itemNameHasBeenSet;
+
+    Aws::Vector<Attribute> m_attributes;
+    bool m_attributesHasBeenSet;
+
+    UpdateCondition m_expected;
+    bool m_expectedHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/DeleteDomainRequest.h

@@ -0,0 +1,87 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/sdb/SimpleDBRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SIMPLEDB_API DeleteDomainRequest : public SimpleDBRequest
+  {
+  public:
+    DeleteDomainRequest();
+
+    // 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 "DeleteDomain"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * The name of the domain to delete.
+     */
+    inline const Aws::String& GetDomainName() const{ return m_domainName; }
+
+    /**
+     * The name of the domain to delete.
+     */
+    inline bool DomainNameHasBeenSet() const { return m_domainNameHasBeenSet; }
+
+    /**
+     * The name of the domain to delete.
+     */
+    inline void SetDomainName(const Aws::String& value) { m_domainNameHasBeenSet = true; m_domainName = value; }
+
+    /**
+     * The name of the domain to delete.
+     */
+    inline void SetDomainName(Aws::String&& value) { m_domainNameHasBeenSet = true; m_domainName = std::move(value); }
+
+    /**
+     * The name of the domain to delete.
+     */
+    inline void SetDomainName(const char* value) { m_domainNameHasBeenSet = true; m_domainName.assign(value); }
+
+    /**
+     * The name of the domain to delete.
+     */
+    inline DeleteDomainRequest& WithDomainName(const Aws::String& value) { SetDomainName(value); return *this;}
+
+    /**
+     * The name of the domain to delete.
+     */
+    inline DeleteDomainRequest& WithDomainName(Aws::String&& value) { SetDomainName(std::move(value)); return *this;}
+
+    /**
+     * The name of the domain to delete.
+     */
+    inline DeleteDomainRequest& WithDomainName(const char* value) { SetDomainName(value); return *this;}
+
+  private:
+
+    Aws::String m_domainName;
+    bool m_domainNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/DomainMetadataRequest.h

@@ -0,0 +1,87 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/sdb/SimpleDBRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SIMPLEDB_API DomainMetadataRequest : public SimpleDBRequest
+  {
+  public:
+    DomainMetadataRequest();
+
+    // 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 "DomainMetadata"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * The name of the domain for which to display the metadata of.
+     */
+    inline const Aws::String& GetDomainName() const{ return m_domainName; }
+
+    /**
+     * The name of the domain for which to display the metadata of.
+     */
+    inline bool DomainNameHasBeenSet() const { return m_domainNameHasBeenSet; }
+
+    /**
+     * The name of the domain for which to display the metadata of.
+     */
+    inline void SetDomainName(const Aws::String& value) { m_domainNameHasBeenSet = true; m_domainName = value; }
+
+    /**
+     * The name of the domain for which to display the metadata of.
+     */
+    inline void SetDomainName(Aws::String&& value) { m_domainNameHasBeenSet = true; m_domainName = std::move(value); }
+
+    /**
+     * The name of the domain for which to display the metadata of.
+     */
+    inline void SetDomainName(const char* value) { m_domainNameHasBeenSet = true; m_domainName.assign(value); }
+
+    /**
+     * The name of the domain for which to display the metadata of.
+     */
+    inline DomainMetadataRequest& WithDomainName(const Aws::String& value) { SetDomainName(value); return *this;}
+
+    /**
+     * The name of the domain for which to display the metadata of.
+     */
+    inline DomainMetadataRequest& WithDomainName(Aws::String&& value) { SetDomainName(std::move(value)); return *this;}
+
+    /**
+     * The name of the domain for which to display the metadata of.
+     */
+    inline DomainMetadataRequest& WithDomainName(const char* value) { SetDomainName(value); return *this;}
+
+  private:
+
+    Aws::String m_domainName;
+    bool m_domainNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/DomainMetadataResult.h

@@ -0,0 +1,183 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/sdb/model/ResponseMetadata.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace SimpleDB
+{
+namespace Model
+{
+  class AWS_SIMPLEDB_API DomainMetadataResult
+  {
+  public:
+    DomainMetadataResult();
+    DomainMetadataResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    DomainMetadataResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    /**
+     * The number of all items in the domain.
+     */
+    inline int GetItemCount() const{ return m_itemCount; }
+
+    /**
+     * The number of all items in the domain.
+     */
+    inline void SetItemCount(int value) { m_itemCount = value; }
+
+    /**
+     * The number of all items in the domain.
+     */
+    inline DomainMetadataResult& WithItemCount(int value) { SetItemCount(value); return *this;}
+
+
+    /**
+     * The total size of all item names in the domain, in bytes.
+     */
+    inline long long GetItemNamesSizeBytes() const{ return m_itemNamesSizeBytes; }
+
+    /**
+     * The total size of all item names in the domain, in bytes.
+     */
+    inline void SetItemNamesSizeBytes(long long value) { m_itemNamesSizeBytes = value; }
+
+    /**
+     * The total size of all item names in the domain, in bytes.
+     */
+    inline DomainMetadataResult& WithItemNamesSizeBytes(long long value) { SetItemNamesSizeBytes(value); return *this;}
+
+
+    /**
+     * The number of unique attribute names in the domain.
+     */
+    inline int GetAttributeNameCount() const{ return m_attributeNameCount; }
+
+    /**
+     * The number of unique attribute names in the domain.
+     */
+    inline void SetAttributeNameCount(int value) { m_attributeNameCount = value; }
+
+    /**
+     * The number of unique attribute names in the domain.
+     */
+    inline DomainMetadataResult& WithAttributeNameCount(int value) { SetAttributeNameCount(value); return *this;}
+
+
+    /**
+     * The total size of all unique attribute names in the domain, in bytes.
+     */
+    inline long long GetAttributeNamesSizeBytes() const{ return m_attributeNamesSizeBytes; }
+
+    /**
+     * The total size of all unique attribute names in the domain, in bytes.
+     */
+    inline void SetAttributeNamesSizeBytes(long long value) { m_attributeNamesSizeBytes = value; }
+
+    /**
+     * The total size of all unique attribute names in the domain, in bytes.
+     */
+    inline DomainMetadataResult& WithAttributeNamesSizeBytes(long long value) { SetAttributeNamesSizeBytes(value); return *this;}
+
+
+    /**
+     * The number of all attribute name/value pairs in the domain.
+     */
+    inline int GetAttributeValueCount() const{ return m_attributeValueCount; }
+
+    /**
+     * The number of all attribute name/value pairs in the domain.
+     */
+    inline void SetAttributeValueCount(int value) { m_attributeValueCount = value; }
+
+    /**
+     * The number of all attribute name/value pairs in the domain.
+     */
+    inline DomainMetadataResult& WithAttributeValueCount(int value) { SetAttributeValueCount(value); return *this;}
+
+
+    /**
+     * The total size of all attribute values in the domain, in bytes.
+     */
+    inline long long GetAttributeValuesSizeBytes() const{ return m_attributeValuesSizeBytes; }
+
+    /**
+     * The total size of all attribute values in the domain, in bytes.
+     */
+    inline void SetAttributeValuesSizeBytes(long long value) { m_attributeValuesSizeBytes = value; }
+
+    /**
+     * The total size of all attribute values in the domain, in bytes.
+     */
+    inline DomainMetadataResult& WithAttributeValuesSizeBytes(long long value) { SetAttributeValuesSizeBytes(value); return *this;}
+
+
+    /**
+     * The data and time when metadata was calculated, in Epoch (UNIX) seconds.
+     */
+    inline int GetTimestamp() const{ return m_timestamp; }
+
+    /**
+     * The data and time when metadata was calculated, in Epoch (UNIX) seconds.
+     */
+    inline void SetTimestamp(int value) { m_timestamp = value; }
+
+    /**
+     * The data and time when metadata was calculated, in Epoch (UNIX) seconds.
+     */
+    inline DomainMetadataResult& WithTimestamp(int value) { SetTimestamp(value); return *this;}
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline DomainMetadataResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline DomainMetadataResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    int m_itemCount;
+
+    long long m_itemNamesSizeBytes;
+
+    int m_attributeNameCount;
+
+    long long m_attributeNamesSizeBytes;
+
+    int m_attributeValueCount;
+
+    long long m_attributeValuesSizeBytes;
+
+    int m_timestamp;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/DuplicateItemName.h

@@ -0,0 +1,60 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   * <p>The item name was specified more than once. </p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/DuplicateItemName">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SIMPLEDB_API DuplicateItemName
+  {
+  public:
+    DuplicateItemName();
+    DuplicateItemName(const Aws::Utils::Xml::XmlNode& xmlNode);
+    DuplicateItemName& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    
+    inline double GetBoxUsage() const{ return m_boxUsage; }
+
+    
+    inline bool BoxUsageHasBeenSet() const { return m_boxUsageHasBeenSet; }
+
+    
+    inline void SetBoxUsage(double value) { m_boxUsageHasBeenSet = true; m_boxUsage = value; }
+
+    
+    inline DuplicateItemName& WithBoxUsage(double value) { SetBoxUsage(value); return *this;}
+
+  private:
+
+    double m_boxUsage;
+    bool m_boxUsageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/GetAttributesRequest.h

@@ -0,0 +1,217 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/sdb/SimpleDBRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SIMPLEDB_API GetAttributesRequest : public SimpleDBRequest
+  {
+  public:
+    GetAttributesRequest();
+
+    // 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 "GetAttributes"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * The name of the domain in which to perform the operation.
+     */
+    inline const Aws::String& GetDomainName() const{ return m_domainName; }
+
+    /**
+     * The name of the domain in which to perform the operation.
+     */
+    inline bool DomainNameHasBeenSet() const { return m_domainNameHasBeenSet; }
+
+    /**
+     * The name of the domain in which to perform the operation.
+     */
+    inline void SetDomainName(const Aws::String& value) { m_domainNameHasBeenSet = true; m_domainName = value; }
+
+    /**
+     * The name of the domain in which to perform the operation.
+     */
+    inline void SetDomainName(Aws::String&& value) { m_domainNameHasBeenSet = true; m_domainName = std::move(value); }
+
+    /**
+     * The name of the domain in which to perform the operation.
+     */
+    inline void SetDomainName(const char* value) { m_domainNameHasBeenSet = true; m_domainName.assign(value); }
+
+    /**
+     * The name of the domain in which to perform the operation.
+     */
+    inline GetAttributesRequest& WithDomainName(const Aws::String& value) { SetDomainName(value); return *this;}
+
+    /**
+     * The name of the domain in which to perform the operation.
+     */
+    inline GetAttributesRequest& WithDomainName(Aws::String&& value) { SetDomainName(std::move(value)); return *this;}
+
+    /**
+     * The name of the domain in which to perform the operation.
+     */
+    inline GetAttributesRequest& WithDomainName(const char* value) { SetDomainName(value); return *this;}
+
+
+    /**
+     * The name of the item.
+     */
+    inline const Aws::String& GetItemName() const{ return m_itemName; }
+
+    /**
+     * The name of the item.
+     */
+    inline bool ItemNameHasBeenSet() const { return m_itemNameHasBeenSet; }
+
+    /**
+     * The name of the item.
+     */
+    inline void SetItemName(const Aws::String& value) { m_itemNameHasBeenSet = true; m_itemName = value; }
+
+    /**
+     * The name of the item.
+     */
+    inline void SetItemName(Aws::String&& value) { m_itemNameHasBeenSet = true; m_itemName = std::move(value); }
+
+    /**
+     * The name of the item.
+     */
+    inline void SetItemName(const char* value) { m_itemNameHasBeenSet = true; m_itemName.assign(value); }
+
+    /**
+     * The name of the item.
+     */
+    inline GetAttributesRequest& WithItemName(const Aws::String& value) { SetItemName(value); return *this;}
+
+    /**
+     * The name of the item.
+     */
+    inline GetAttributesRequest& WithItemName(Aws::String&& value) { SetItemName(std::move(value)); return *this;}
+
+    /**
+     * The name of the item.
+     */
+    inline GetAttributesRequest& WithItemName(const char* value) { SetItemName(value); return *this;}
+
+
+    /**
+     * The names of the attributes.
+     */
+    inline const Aws::Vector<Aws::String>& GetAttributeNames() const{ return m_attributeNames; }
+
+    /**
+     * The names of the attributes.
+     */
+    inline bool AttributeNamesHasBeenSet() const { return m_attributeNamesHasBeenSet; }
+
+    /**
+     * The names of the attributes.
+     */
+    inline void SetAttributeNames(const Aws::Vector<Aws::String>& value) { m_attributeNamesHasBeenSet = true; m_attributeNames = value; }
+
+    /**
+     * The names of the attributes.
+     */
+    inline void SetAttributeNames(Aws::Vector<Aws::String>&& value) { m_attributeNamesHasBeenSet = true; m_attributeNames = std::move(value); }
+
+    /**
+     * The names of the attributes.
+     */
+    inline GetAttributesRequest& WithAttributeNames(const Aws::Vector<Aws::String>& value) { SetAttributeNames(value); return *this;}
+
+    /**
+     * The names of the attributes.
+     */
+    inline GetAttributesRequest& WithAttributeNames(Aws::Vector<Aws::String>&& value) { SetAttributeNames(std::move(value)); return *this;}
+
+    /**
+     * The names of the attributes.
+     */
+    inline GetAttributesRequest& AddAttributeNames(const Aws::String& value) { m_attributeNamesHasBeenSet = true; m_attributeNames.push_back(value); return *this; }
+
+    /**
+     * The names of the attributes.
+     */
+    inline GetAttributesRequest& AddAttributeNames(Aws::String&& value) { m_attributeNamesHasBeenSet = true; m_attributeNames.push_back(std::move(value)); return *this; }
+
+    /**
+     * The names of the attributes.
+     */
+    inline GetAttributesRequest& AddAttributeNames(const char* value) { m_attributeNamesHasBeenSet = true; m_attributeNames.push_back(value); return *this; }
+
+
+    /**
+     * Determines whether or not strong consistency should be enforced when data is
+     * read from SimpleDB. If <code>true</code>, any data previously written to
+     * SimpleDB will be returned. Otherwise, results will be consistent eventually, and
+     * the client may not see data that was written immediately before your read.
+     */
+    inline bool GetConsistentRead() const{ return m_consistentRead; }
+
+    /**
+     * Determines whether or not strong consistency should be enforced when data is
+     * read from SimpleDB. If <code>true</code>, any data previously written to
+     * SimpleDB will be returned. Otherwise, results will be consistent eventually, and
+     * the client may not see data that was written immediately before your read.
+     */
+    inline bool ConsistentReadHasBeenSet() const { return m_consistentReadHasBeenSet; }
+
+    /**
+     * Determines whether or not strong consistency should be enforced when data is
+     * read from SimpleDB. If <code>true</code>, any data previously written to
+     * SimpleDB will be returned. Otherwise, results will be consistent eventually, and
+     * the client may not see data that was written immediately before your read.
+     */
+    inline void SetConsistentRead(bool value) { m_consistentReadHasBeenSet = true; m_consistentRead = value; }
+
+    /**
+     * Determines whether or not strong consistency should be enforced when data is
+     * read from SimpleDB. If <code>true</code>, any data previously written to
+     * SimpleDB will be returned. Otherwise, results will be consistent eventually, and
+     * the client may not see data that was written immediately before your read.
+     */
+    inline GetAttributesRequest& WithConsistentRead(bool value) { SetConsistentRead(value); return *this;}
+
+  private:
+
+    Aws::String m_domainName;
+    bool m_domainNameHasBeenSet;
+
+    Aws::String m_itemName;
+    bool m_itemNameHasBeenSet;
+
+    Aws::Vector<Aws::String> m_attributeNames;
+    bool m_attributeNamesHasBeenSet;
+
+    bool m_consistentRead;
+    bool m_consistentReadHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/GetAttributesResult.h

@@ -0,0 +1,97 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/sdb/model/ResponseMetadata.h>
+#include <aws/sdb/model/Attribute.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace SimpleDB
+{
+namespace Model
+{
+  class AWS_SIMPLEDB_API GetAttributesResult
+  {
+  public:
+    GetAttributesResult();
+    GetAttributesResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    GetAttributesResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    /**
+     * The list of attributes returned by the operation.
+     */
+    inline const Aws::Vector<Attribute>& GetAttributes() const{ return m_attributes; }
+
+    /**
+     * The list of attributes returned by the operation.
+     */
+    inline void SetAttributes(const Aws::Vector<Attribute>& value) { m_attributes = value; }
+
+    /**
+     * The list of attributes returned by the operation.
+     */
+    inline void SetAttributes(Aws::Vector<Attribute>&& value) { m_attributes = std::move(value); }
+
+    /**
+     * The list of attributes returned by the operation.
+     */
+    inline GetAttributesResult& WithAttributes(const Aws::Vector<Attribute>& value) { SetAttributes(value); return *this;}
+
+    /**
+     * The list of attributes returned by the operation.
+     */
+    inline GetAttributesResult& WithAttributes(Aws::Vector<Attribute>&& value) { SetAttributes(std::move(value)); return *this;}
+
+    /**
+     * The list of attributes returned by the operation.
+     */
+    inline GetAttributesResult& AddAttributes(const Attribute& value) { m_attributes.push_back(value); return *this; }
+
+    /**
+     * The list of attributes returned by the operation.
+     */
+    inline GetAttributesResult& AddAttributes(Attribute&& value) { m_attributes.push_back(std::move(value)); return *this; }
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline GetAttributesResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline GetAttributesResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    Aws::Vector<Attribute> m_attributes;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/InvalidNextToken.h

@@ -0,0 +1,60 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   * <p>The specified NextToken is not valid. </p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/InvalidNextToken">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SIMPLEDB_API InvalidNextToken
+  {
+  public:
+    InvalidNextToken();
+    InvalidNextToken(const Aws::Utils::Xml::XmlNode& xmlNode);
+    InvalidNextToken& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    
+    inline double GetBoxUsage() const{ return m_boxUsage; }
+
+    
+    inline bool BoxUsageHasBeenSet() const { return m_boxUsageHasBeenSet; }
+
+    
+    inline void SetBoxUsage(double value) { m_boxUsageHasBeenSet = true; m_boxUsage = value; }
+
+    
+    inline InvalidNextToken& WithBoxUsage(double value) { SetBoxUsage(value); return *this;}
+
+  private:
+
+    double m_boxUsage;
+    bool m_boxUsageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/InvalidNumberPredicates.h

@@ -0,0 +1,61 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Too many predicates exist in the query expression.</p><p><h3>See Also:</h3>  
+   * <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/InvalidNumberPredicates">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SIMPLEDB_API InvalidNumberPredicates
+  {
+  public:
+    InvalidNumberPredicates();
+    InvalidNumberPredicates(const Aws::Utils::Xml::XmlNode& xmlNode);
+    InvalidNumberPredicates& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    
+    inline double GetBoxUsage() const{ return m_boxUsage; }
+
+    
+    inline bool BoxUsageHasBeenSet() const { return m_boxUsageHasBeenSet; }
+
+    
+    inline void SetBoxUsage(double value) { m_boxUsageHasBeenSet = true; m_boxUsage = value; }
+
+    
+    inline InvalidNumberPredicates& WithBoxUsage(double value) { SetBoxUsage(value); return *this;}
+
+  private:
+
+    double m_boxUsage;
+    bool m_boxUsageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/InvalidNumberValueTests.h

@@ -0,0 +1,61 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Too many predicates exist in the query expression.</p><p><h3>See Also:</h3>  
+   * <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/InvalidNumberValueTests">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SIMPLEDB_API InvalidNumberValueTests
+  {
+  public:
+    InvalidNumberValueTests();
+    InvalidNumberValueTests(const Aws::Utils::Xml::XmlNode& xmlNode);
+    InvalidNumberValueTests& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    
+    inline double GetBoxUsage() const{ return m_boxUsage; }
+
+    
+    inline bool BoxUsageHasBeenSet() const { return m_boxUsageHasBeenSet; }
+
+    
+    inline void SetBoxUsage(double value) { m_boxUsageHasBeenSet = true; m_boxUsage = value; }
+
+    
+    inline InvalidNumberValueTests& WithBoxUsage(double value) { SetBoxUsage(value); return *this;}
+
+  private:
+
+    double m_boxUsage;
+    bool m_boxUsageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/InvalidParameterValue.h

@@ -0,0 +1,60 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   * <p>The value for a parameter is invalid.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/InvalidParameterValue">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SIMPLEDB_API InvalidParameterValue
+  {
+  public:
+    InvalidParameterValue();
+    InvalidParameterValue(const Aws::Utils::Xml::XmlNode& xmlNode);
+    InvalidParameterValue& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    
+    inline double GetBoxUsage() const{ return m_boxUsage; }
+
+    
+    inline bool BoxUsageHasBeenSet() const { return m_boxUsageHasBeenSet; }
+
+    
+    inline void SetBoxUsage(double value) { m_boxUsageHasBeenSet = true; m_boxUsage = value; }
+
+    
+    inline InvalidParameterValue& WithBoxUsage(double value) { SetBoxUsage(value); return *this;}
+
+  private:
+
+    double m_boxUsage;
+    bool m_boxUsageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/InvalidQueryExpression.h

@@ -0,0 +1,61 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   * <p>The specified query expression syntax is not valid.</p><p><h3>See Also:</h3> 
+   * <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/InvalidQueryExpression">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SIMPLEDB_API InvalidQueryExpression
+  {
+  public:
+    InvalidQueryExpression();
+    InvalidQueryExpression(const Aws::Utils::Xml::XmlNode& xmlNode);
+    InvalidQueryExpression& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    
+    inline double GetBoxUsage() const{ return m_boxUsage; }
+
+    
+    inline bool BoxUsageHasBeenSet() const { return m_boxUsageHasBeenSet; }
+
+    
+    inline void SetBoxUsage(double value) { m_boxUsageHasBeenSet = true; m_boxUsage = value; }
+
+    
+    inline InvalidQueryExpression& WithBoxUsage(double value) { SetBoxUsage(value); return *this;}
+
+  private:
+
+    double m_boxUsage;
+    bool m_boxUsageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/Item.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/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/sdb/model/Attribute.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   * <p></p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/Item">AWS API
+   * Reference</a></p>
+   */
+  class AWS_SIMPLEDB_API Item
+  {
+  public:
+    Item();
+    Item(const Aws::Utils::Xml::XmlNode& xmlNode);
+    Item& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    /**
+     * The name of the item.
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * The name of the item.
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * The name of the item.
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * The name of the item.
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * The name of the item.
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * The name of the item.
+     */
+    inline Item& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * The name of the item.
+     */
+    inline Item& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * The name of the item.
+     */
+    inline Item& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * <p></p>
+     */
+    inline const Aws::String& GetAlternateNameEncoding() const{ return m_alternateNameEncoding; }
+
+    /**
+     * <p></p>
+     */
+    inline bool AlternateNameEncodingHasBeenSet() const { return m_alternateNameEncodingHasBeenSet; }
+
+    /**
+     * <p></p>
+     */
+    inline void SetAlternateNameEncoding(const Aws::String& value) { m_alternateNameEncodingHasBeenSet = true; m_alternateNameEncoding = value; }
+
+    /**
+     * <p></p>
+     */
+    inline void SetAlternateNameEncoding(Aws::String&& value) { m_alternateNameEncodingHasBeenSet = true; m_alternateNameEncoding = std::move(value); }
+
+    /**
+     * <p></p>
+     */
+    inline void SetAlternateNameEncoding(const char* value) { m_alternateNameEncodingHasBeenSet = true; m_alternateNameEncoding.assign(value); }
+
+    /**
+     * <p></p>
+     */
+    inline Item& WithAlternateNameEncoding(const Aws::String& value) { SetAlternateNameEncoding(value); return *this;}
+
+    /**
+     * <p></p>
+     */
+    inline Item& WithAlternateNameEncoding(Aws::String&& value) { SetAlternateNameEncoding(std::move(value)); return *this;}
+
+    /**
+     * <p></p>
+     */
+    inline Item& WithAlternateNameEncoding(const char* value) { SetAlternateNameEncoding(value); return *this;}
+
+
+    /**
+     * A list of attributes.
+     */
+    inline const Aws::Vector<Attribute>& GetAttributes() const{ return m_attributes; }
+
+    /**
+     * A list of attributes.
+     */
+    inline bool AttributesHasBeenSet() const { return m_attributesHasBeenSet; }
+
+    /**
+     * A list of attributes.
+     */
+    inline void SetAttributes(const Aws::Vector<Attribute>& value) { m_attributesHasBeenSet = true; m_attributes = value; }
+
+    /**
+     * A list of attributes.
+     */
+    inline void SetAttributes(Aws::Vector<Attribute>&& value) { m_attributesHasBeenSet = true; m_attributes = std::move(value); }
+
+    /**
+     * A list of attributes.
+     */
+    inline Item& WithAttributes(const Aws::Vector<Attribute>& value) { SetAttributes(value); return *this;}
+
+    /**
+     * A list of attributes.
+     */
+    inline Item& WithAttributes(Aws::Vector<Attribute>&& value) { SetAttributes(std::move(value)); return *this;}
+
+    /**
+     * A list of attributes.
+     */
+    inline Item& AddAttributes(const Attribute& value) { m_attributesHasBeenSet = true; m_attributes.push_back(value); return *this; }
+
+    /**
+     * A list of attributes.
+     */
+    inline Item& AddAttributes(Attribute&& value) { m_attributesHasBeenSet = true; m_attributes.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    Aws::String m_alternateNameEncoding;
+    bool m_alternateNameEncodingHasBeenSet;
+
+    Aws::Vector<Attribute> m_attributes;
+    bool m_attributesHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/ListDomainsRequest.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/sdb/SimpleDB_EXPORTS.h>
+#include <aws/sdb/SimpleDBRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SIMPLEDB_API ListDomainsRequest : public SimpleDBRequest
+  {
+  public:
+    ListDomainsRequest();
+
+    // 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 "ListDomains"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * The maximum number of domain names you want returned. The range is 1 to 100. The
+     * default setting is 100.
+     */
+    inline int GetMaxNumberOfDomains() const{ return m_maxNumberOfDomains; }
+
+    /**
+     * The maximum number of domain names you want returned. The range is 1 to 100. The
+     * default setting is 100.
+     */
+    inline bool MaxNumberOfDomainsHasBeenSet() const { return m_maxNumberOfDomainsHasBeenSet; }
+
+    /**
+     * The maximum number of domain names you want returned. The range is 1 to 100. The
+     * default setting is 100.
+     */
+    inline void SetMaxNumberOfDomains(int value) { m_maxNumberOfDomainsHasBeenSet = true; m_maxNumberOfDomains = value; }
+
+    /**
+     * The maximum number of domain names you want returned. The range is 1 to 100. The
+     * default setting is 100.
+     */
+    inline ListDomainsRequest& WithMaxNumberOfDomains(int value) { SetMaxNumberOfDomains(value); return *this;}
+
+
+    /**
+     * A string informing Amazon SimpleDB where to start the next list of domain names.
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * A string informing Amazon SimpleDB where to start the next list of domain names.
+     */
+    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+
+    /**
+     * A string informing Amazon SimpleDB where to start the next list of domain names.
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
+
+    /**
+     * A string informing Amazon SimpleDB where to start the next list of domain names.
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
+
+    /**
+     * A string informing Amazon SimpleDB where to start the next list of domain names.
+     */
+    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
+
+    /**
+     * A string informing Amazon SimpleDB where to start the next list of domain names.
+     */
+    inline ListDomainsRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * A string informing Amazon SimpleDB where to start the next list of domain names.
+     */
+    inline ListDomainsRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * A string informing Amazon SimpleDB where to start the next list of domain names.
+     */
+    inline ListDomainsRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+  private:
+
+    int m_maxNumberOfDomains;
+    bool m_maxNumberOfDomainsHasBeenSet;
+
+    Aws::String m_nextToken;
+    bool m_nextTokenHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/ListDomainsResult.h

@@ -0,0 +1,147 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/sdb/model/ResponseMetadata.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace SimpleDB
+{
+namespace Model
+{
+  class AWS_SIMPLEDB_API ListDomainsResult
+  {
+  public:
+    ListDomainsResult();
+    ListDomainsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    ListDomainsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    /**
+     * A list of domain names that match the expression.
+     */
+    inline const Aws::Vector<Aws::String>& GetDomainNames() const{ return m_domainNames; }
+
+    /**
+     * A list of domain names that match the expression.
+     */
+    inline void SetDomainNames(const Aws::Vector<Aws::String>& value) { m_domainNames = value; }
+
+    /**
+     * A list of domain names that match the expression.
+     */
+    inline void SetDomainNames(Aws::Vector<Aws::String>&& value) { m_domainNames = std::move(value); }
+
+    /**
+     * A list of domain names that match the expression.
+     */
+    inline ListDomainsResult& WithDomainNames(const Aws::Vector<Aws::String>& value) { SetDomainNames(value); return *this;}
+
+    /**
+     * A list of domain names that match the expression.
+     */
+    inline ListDomainsResult& WithDomainNames(Aws::Vector<Aws::String>&& value) { SetDomainNames(std::move(value)); return *this;}
+
+    /**
+     * A list of domain names that match the expression.
+     */
+    inline ListDomainsResult& AddDomainNames(const Aws::String& value) { m_domainNames.push_back(value); return *this; }
+
+    /**
+     * A list of domain names that match the expression.
+     */
+    inline ListDomainsResult& AddDomainNames(Aws::String&& value) { m_domainNames.push_back(std::move(value)); return *this; }
+
+    /**
+     * A list of domain names that match the expression.
+     */
+    inline ListDomainsResult& AddDomainNames(const char* value) { m_domainNames.push_back(value); return *this; }
+
+
+    /**
+     * An opaque token indicating that there are more domains than the specified
+     * <code>MaxNumberOfDomains</code> still available.
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * An opaque token indicating that there are more domains than the specified
+     * <code>MaxNumberOfDomains</code> still available.
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
+
+    /**
+     * An opaque token indicating that there are more domains than the specified
+     * <code>MaxNumberOfDomains</code> still available.
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
+
+    /**
+     * An opaque token indicating that there are more domains than the specified
+     * <code>MaxNumberOfDomains</code> still available.
+     */
+    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
+
+    /**
+     * An opaque token indicating that there are more domains than the specified
+     * <code>MaxNumberOfDomains</code> still available.
+     */
+    inline ListDomainsResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * An opaque token indicating that there are more domains than the specified
+     * <code>MaxNumberOfDomains</code> still available.
+     */
+    inline ListDomainsResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * An opaque token indicating that there are more domains than the specified
+     * <code>MaxNumberOfDomains</code> still available.
+     */
+    inline ListDomainsResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline ListDomainsResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline ListDomainsResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    Aws::Vector<Aws::String> m_domainNames;
+
+    Aws::String m_nextToken;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/MissingParameter.h

@@ -0,0 +1,61 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   * <p>The request must contain the specified missing parameter.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/MissingParameter">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SIMPLEDB_API MissingParameter
+  {
+  public:
+    MissingParameter();
+    MissingParameter(const Aws::Utils::Xml::XmlNode& xmlNode);
+    MissingParameter& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    
+    inline double GetBoxUsage() const{ return m_boxUsage; }
+
+    
+    inline bool BoxUsageHasBeenSet() const { return m_boxUsageHasBeenSet; }
+
+    
+    inline void SetBoxUsage(double value) { m_boxUsageHasBeenSet = true; m_boxUsage = value; }
+
+    
+    inline MissingParameter& WithBoxUsage(double value) { SetBoxUsage(value); return *this;}
+
+  private:
+
+    double m_boxUsage;
+    bool m_boxUsageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/NoSuchDomain.h

@@ -0,0 +1,60 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   * <p>The specified domain does not exist.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/NoSuchDomain">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SIMPLEDB_API NoSuchDomain
+  {
+  public:
+    NoSuchDomain();
+    NoSuchDomain(const Aws::Utils::Xml::XmlNode& xmlNode);
+    NoSuchDomain& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    
+    inline double GetBoxUsage() const{ return m_boxUsage; }
+
+    
+    inline bool BoxUsageHasBeenSet() const { return m_boxUsageHasBeenSet; }
+
+    
+    inline void SetBoxUsage(double value) { m_boxUsageHasBeenSet = true; m_boxUsage = value; }
+
+    
+    inline NoSuchDomain& WithBoxUsage(double value) { SetBoxUsage(value); return *this;}
+
+  private:
+
+    double m_boxUsage;
+    bool m_boxUsageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/NumberDomainAttributesExceeded.h

@@ -0,0 +1,60 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Too many attributes in this domain.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/NumberDomainAttributesExceeded">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SIMPLEDB_API NumberDomainAttributesExceeded
+  {
+  public:
+    NumberDomainAttributesExceeded();
+    NumberDomainAttributesExceeded(const Aws::Utils::Xml::XmlNode& xmlNode);
+    NumberDomainAttributesExceeded& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    
+    inline double GetBoxUsage() const{ return m_boxUsage; }
+
+    
+    inline bool BoxUsageHasBeenSet() const { return m_boxUsageHasBeenSet; }
+
+    
+    inline void SetBoxUsage(double value) { m_boxUsageHasBeenSet = true; m_boxUsage = value; }
+
+    
+    inline NumberDomainAttributesExceeded& WithBoxUsage(double value) { SetBoxUsage(value); return *this;}
+
+  private:
+
+    double m_boxUsage;
+    bool m_boxUsageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/NumberDomainBytesExceeded.h

@@ -0,0 +1,60 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Too many bytes in this domain.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/NumberDomainBytesExceeded">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SIMPLEDB_API NumberDomainBytesExceeded
+  {
+  public:
+    NumberDomainBytesExceeded();
+    NumberDomainBytesExceeded(const Aws::Utils::Xml::XmlNode& xmlNode);
+    NumberDomainBytesExceeded& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    
+    inline double GetBoxUsage() const{ return m_boxUsage; }
+
+    
+    inline bool BoxUsageHasBeenSet() const { return m_boxUsageHasBeenSet; }
+
+    
+    inline void SetBoxUsage(double value) { m_boxUsageHasBeenSet = true; m_boxUsage = value; }
+
+    
+    inline NumberDomainBytesExceeded& WithBoxUsage(double value) { SetBoxUsage(value); return *this;}
+
+  private:
+
+    double m_boxUsage;
+    bool m_boxUsageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/NumberDomainsExceeded.h

@@ -0,0 +1,60 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Too many domains exist per this account.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/NumberDomainsExceeded">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SIMPLEDB_API NumberDomainsExceeded
+  {
+  public:
+    NumberDomainsExceeded();
+    NumberDomainsExceeded(const Aws::Utils::Xml::XmlNode& xmlNode);
+    NumberDomainsExceeded& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    
+    inline double GetBoxUsage() const{ return m_boxUsage; }
+
+    
+    inline bool BoxUsageHasBeenSet() const { return m_boxUsageHasBeenSet; }
+
+    
+    inline void SetBoxUsage(double value) { m_boxUsageHasBeenSet = true; m_boxUsage = value; }
+
+    
+    inline NumberDomainsExceeded& WithBoxUsage(double value) { SetBoxUsage(value); return *this;}
+
+  private:
+
+    double m_boxUsage;
+    bool m_boxUsageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/NumberItemAttributesExceeded.h

@@ -0,0 +1,60 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Too many attributes in this item.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/NumberItemAttributesExceeded">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SIMPLEDB_API NumberItemAttributesExceeded
+  {
+  public:
+    NumberItemAttributesExceeded();
+    NumberItemAttributesExceeded(const Aws::Utils::Xml::XmlNode& xmlNode);
+    NumberItemAttributesExceeded& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    
+    inline double GetBoxUsage() const{ return m_boxUsage; }
+
+    
+    inline bool BoxUsageHasBeenSet() const { return m_boxUsageHasBeenSet; }
+
+    
+    inline void SetBoxUsage(double value) { m_boxUsageHasBeenSet = true; m_boxUsage = value; }
+
+    
+    inline NumberItemAttributesExceeded& WithBoxUsage(double value) { SetBoxUsage(value); return *this;}
+
+  private:
+
+    double m_boxUsage;
+    bool m_boxUsageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/NumberSubmittedAttributesExceeded.h

@@ -0,0 +1,60 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Too many attributes exist in a single call.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/NumberSubmittedAttributesExceeded">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SIMPLEDB_API NumberSubmittedAttributesExceeded
+  {
+  public:
+    NumberSubmittedAttributesExceeded();
+    NumberSubmittedAttributesExceeded(const Aws::Utils::Xml::XmlNode& xmlNode);
+    NumberSubmittedAttributesExceeded& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    
+    inline double GetBoxUsage() const{ return m_boxUsage; }
+
+    
+    inline bool BoxUsageHasBeenSet() const { return m_boxUsageHasBeenSet; }
+
+    
+    inline void SetBoxUsage(double value) { m_boxUsageHasBeenSet = true; m_boxUsage = value; }
+
+    
+    inline NumberSubmittedAttributesExceeded& WithBoxUsage(double value) { SetBoxUsage(value); return *this;}
+
+  private:
+
+    double m_boxUsage;
+    bool m_boxUsageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/NumberSubmittedItemsExceeded.h

@@ -0,0 +1,60 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Too many items exist in a single call.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/NumberSubmittedItemsExceeded">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SIMPLEDB_API NumberSubmittedItemsExceeded
+  {
+  public:
+    NumberSubmittedItemsExceeded();
+    NumberSubmittedItemsExceeded(const Aws::Utils::Xml::XmlNode& xmlNode);
+    NumberSubmittedItemsExceeded& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    
+    inline double GetBoxUsage() const{ return m_boxUsage; }
+
+    
+    inline bool BoxUsageHasBeenSet() const { return m_boxUsageHasBeenSet; }
+
+    
+    inline void SetBoxUsage(double value) { m_boxUsageHasBeenSet = true; m_boxUsage = value; }
+
+    
+    inline NumberSubmittedItemsExceeded& WithBoxUsage(double value) { SetBoxUsage(value); return *this;}
+
+  private:
+
+    double m_boxUsage;
+    bool m_boxUsageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/PutAttributesRequest.h

@@ -0,0 +1,224 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/sdb/SimpleDBRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/sdb/model/UpdateCondition.h>
+#include <aws/sdb/model/ReplaceableAttribute.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SIMPLEDB_API PutAttributesRequest : public SimpleDBRequest
+  {
+  public:
+    PutAttributesRequest();
+
+    // 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 "PutAttributes"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * The name of the domain in which to perform the operation.
+     */
+    inline const Aws::String& GetDomainName() const{ return m_domainName; }
+
+    /**
+     * The name of the domain in which to perform the operation.
+     */
+    inline bool DomainNameHasBeenSet() const { return m_domainNameHasBeenSet; }
+
+    /**
+     * The name of the domain in which to perform the operation.
+     */
+    inline void SetDomainName(const Aws::String& value) { m_domainNameHasBeenSet = true; m_domainName = value; }
+
+    /**
+     * The name of the domain in which to perform the operation.
+     */
+    inline void SetDomainName(Aws::String&& value) { m_domainNameHasBeenSet = true; m_domainName = std::move(value); }
+
+    /**
+     * The name of the domain in which to perform the operation.
+     */
+    inline void SetDomainName(const char* value) { m_domainNameHasBeenSet = true; m_domainName.assign(value); }
+
+    /**
+     * The name of the domain in which to perform the operation.
+     */
+    inline PutAttributesRequest& WithDomainName(const Aws::String& value) { SetDomainName(value); return *this;}
+
+    /**
+     * The name of the domain in which to perform the operation.
+     */
+    inline PutAttributesRequest& WithDomainName(Aws::String&& value) { SetDomainName(std::move(value)); return *this;}
+
+    /**
+     * The name of the domain in which to perform the operation.
+     */
+    inline PutAttributesRequest& WithDomainName(const char* value) { SetDomainName(value); return *this;}
+
+
+    /**
+     * The name of the item.
+     */
+    inline const Aws::String& GetItemName() const{ return m_itemName; }
+
+    /**
+     * The name of the item.
+     */
+    inline bool ItemNameHasBeenSet() const { return m_itemNameHasBeenSet; }
+
+    /**
+     * The name of the item.
+     */
+    inline void SetItemName(const Aws::String& value) { m_itemNameHasBeenSet = true; m_itemName = value; }
+
+    /**
+     * The name of the item.
+     */
+    inline void SetItemName(Aws::String&& value) { m_itemNameHasBeenSet = true; m_itemName = std::move(value); }
+
+    /**
+     * The name of the item.
+     */
+    inline void SetItemName(const char* value) { m_itemNameHasBeenSet = true; m_itemName.assign(value); }
+
+    /**
+     * The name of the item.
+     */
+    inline PutAttributesRequest& WithItemName(const Aws::String& value) { SetItemName(value); return *this;}
+
+    /**
+     * The name of the item.
+     */
+    inline PutAttributesRequest& WithItemName(Aws::String&& value) { SetItemName(std::move(value)); return *this;}
+
+    /**
+     * The name of the item.
+     */
+    inline PutAttributesRequest& WithItemName(const char* value) { SetItemName(value); return *this;}
+
+
+    /**
+     * The list of attributes.
+     */
+    inline const Aws::Vector<ReplaceableAttribute>& GetAttributes() const{ return m_attributes; }
+
+    /**
+     * The list of attributes.
+     */
+    inline bool AttributesHasBeenSet() const { return m_attributesHasBeenSet; }
+
+    /**
+     * The list of attributes.
+     */
+    inline void SetAttributes(const Aws::Vector<ReplaceableAttribute>& value) { m_attributesHasBeenSet = true; m_attributes = value; }
+
+    /**
+     * The list of attributes.
+     */
+    inline void SetAttributes(Aws::Vector<ReplaceableAttribute>&& value) { m_attributesHasBeenSet = true; m_attributes = std::move(value); }
+
+    /**
+     * The list of attributes.
+     */
+    inline PutAttributesRequest& WithAttributes(const Aws::Vector<ReplaceableAttribute>& value) { SetAttributes(value); return *this;}
+
+    /**
+     * The list of attributes.
+     */
+    inline PutAttributesRequest& WithAttributes(Aws::Vector<ReplaceableAttribute>&& value) { SetAttributes(std::move(value)); return *this;}
+
+    /**
+     * The list of attributes.
+     */
+    inline PutAttributesRequest& AddAttributes(const ReplaceableAttribute& value) { m_attributesHasBeenSet = true; m_attributes.push_back(value); return *this; }
+
+    /**
+     * The list of attributes.
+     */
+    inline PutAttributesRequest& AddAttributes(ReplaceableAttribute&& value) { m_attributesHasBeenSet = true; m_attributes.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * The update condition which, if specified, determines whether the specified
+     * attributes will be updated or not. The update condition must be satisfied in
+     * order for this request to be processed and the attributes to be updated.
+     */
+    inline const UpdateCondition& GetExpected() const{ return m_expected; }
+
+    /**
+     * The update condition which, if specified, determines whether the specified
+     * attributes will be updated or not. The update condition must be satisfied in
+     * order for this request to be processed and the attributes to be updated.
+     */
+    inline bool ExpectedHasBeenSet() const { return m_expectedHasBeenSet; }
+
+    /**
+     * The update condition which, if specified, determines whether the specified
+     * attributes will be updated or not. The update condition must be satisfied in
+     * order for this request to be processed and the attributes to be updated.
+     */
+    inline void SetExpected(const UpdateCondition& value) { m_expectedHasBeenSet = true; m_expected = value; }
+
+    /**
+     * The update condition which, if specified, determines whether the specified
+     * attributes will be updated or not. The update condition must be satisfied in
+     * order for this request to be processed and the attributes to be updated.
+     */
+    inline void SetExpected(UpdateCondition&& value) { m_expectedHasBeenSet = true; m_expected = std::move(value); }
+
+    /**
+     * The update condition which, if specified, determines whether the specified
+     * attributes will be updated or not. The update condition must be satisfied in
+     * order for this request to be processed and the attributes to be updated.
+     */
+    inline PutAttributesRequest& WithExpected(const UpdateCondition& value) { SetExpected(value); return *this;}
+
+    /**
+     * The update condition which, if specified, determines whether the specified
+     * attributes will be updated or not. The update condition must be satisfied in
+     * order for this request to be processed and the attributes to be updated.
+     */
+    inline PutAttributesRequest& WithExpected(UpdateCondition&& value) { SetExpected(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_domainName;
+    bool m_domainNameHasBeenSet;
+
+    Aws::String m_itemName;
+    bool m_itemNameHasBeenSet;
+
+    Aws::Vector<ReplaceableAttribute> m_attributes;
+    bool m_attributesHasBeenSet;
+
+    UpdateCondition m_expected;
+    bool m_expectedHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/ReplaceableAttribute.h

@@ -0,0 +1,162 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   * <p></p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/ReplaceableAttribute">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SIMPLEDB_API ReplaceableAttribute
+  {
+  public:
+    ReplaceableAttribute();
+    ReplaceableAttribute(const Aws::Utils::Xml::XmlNode& xmlNode);
+    ReplaceableAttribute& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    /**
+     * The name of the replaceable attribute.
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * The name of the replaceable attribute.
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * The name of the replaceable attribute.
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * The name of the replaceable attribute.
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * The name of the replaceable attribute.
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * The name of the replaceable attribute.
+     */
+    inline ReplaceableAttribute& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * The name of the replaceable attribute.
+     */
+    inline ReplaceableAttribute& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * The name of the replaceable attribute.
+     */
+    inline ReplaceableAttribute& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * The value of the replaceable attribute.
+     */
+    inline const Aws::String& GetValue() const{ return m_value; }
+
+    /**
+     * The value of the replaceable attribute.
+     */
+    inline bool ValueHasBeenSet() const { return m_valueHasBeenSet; }
+
+    /**
+     * The value of the replaceable attribute.
+     */
+    inline void SetValue(const Aws::String& value) { m_valueHasBeenSet = true; m_value = value; }
+
+    /**
+     * The value of the replaceable attribute.
+     */
+    inline void SetValue(Aws::String&& value) { m_valueHasBeenSet = true; m_value = std::move(value); }
+
+    /**
+     * The value of the replaceable attribute.
+     */
+    inline void SetValue(const char* value) { m_valueHasBeenSet = true; m_value.assign(value); }
+
+    /**
+     * The value of the replaceable attribute.
+     */
+    inline ReplaceableAttribute& WithValue(const Aws::String& value) { SetValue(value); return *this;}
+
+    /**
+     * The value of the replaceable attribute.
+     */
+    inline ReplaceableAttribute& WithValue(Aws::String&& value) { SetValue(std::move(value)); return *this;}
+
+    /**
+     * The value of the replaceable attribute.
+     */
+    inline ReplaceableAttribute& WithValue(const char* value) { SetValue(value); return *this;}
+
+
+    /**
+     * A flag specifying whether or not to replace the attribute/value pair or to add a
+     * new attribute/value pair. The default setting is <code>false</code>.
+     */
+    inline bool GetReplace() const{ return m_replace; }
+
+    /**
+     * A flag specifying whether or not to replace the attribute/value pair or to add a
+     * new attribute/value pair. The default setting is <code>false</code>.
+     */
+    inline bool ReplaceHasBeenSet() const { return m_replaceHasBeenSet; }
+
+    /**
+     * A flag specifying whether or not to replace the attribute/value pair or to add a
+     * new attribute/value pair. The default setting is <code>false</code>.
+     */
+    inline void SetReplace(bool value) { m_replaceHasBeenSet = true; m_replace = value; }
+
+    /**
+     * A flag specifying whether or not to replace the attribute/value pair or to add a
+     * new attribute/value pair. The default setting is <code>false</code>.
+     */
+    inline ReplaceableAttribute& WithReplace(bool value) { SetReplace(value); return *this;}
+
+  private:
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    Aws::String m_value;
+    bool m_valueHasBeenSet;
+
+    bool m_replace;
+    bool m_replaceHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/ReplaceableItem.h

@@ -0,0 +1,136 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/sdb/model/ReplaceableAttribute.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   * <p></p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/ReplaceableItem">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SIMPLEDB_API ReplaceableItem
+  {
+  public:
+    ReplaceableItem();
+    ReplaceableItem(const Aws::Utils::Xml::XmlNode& xmlNode);
+    ReplaceableItem& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    /**
+     * The name of the replaceable item.
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * The name of the replaceable item.
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * The name of the replaceable item.
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * The name of the replaceable item.
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * The name of the replaceable item.
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * The name of the replaceable item.
+     */
+    inline ReplaceableItem& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * The name of the replaceable item.
+     */
+    inline ReplaceableItem& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * The name of the replaceable item.
+     */
+    inline ReplaceableItem& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * The list of attributes for a replaceable item.
+     */
+    inline const Aws::Vector<ReplaceableAttribute>& GetAttributes() const{ return m_attributes; }
+
+    /**
+     * The list of attributes for a replaceable item.
+     */
+    inline bool AttributesHasBeenSet() const { return m_attributesHasBeenSet; }
+
+    /**
+     * The list of attributes for a replaceable item.
+     */
+    inline void SetAttributes(const Aws::Vector<ReplaceableAttribute>& value) { m_attributesHasBeenSet = true; m_attributes = value; }
+
+    /**
+     * The list of attributes for a replaceable item.
+     */
+    inline void SetAttributes(Aws::Vector<ReplaceableAttribute>&& value) { m_attributesHasBeenSet = true; m_attributes = std::move(value); }
+
+    /**
+     * The list of attributes for a replaceable item.
+     */
+    inline ReplaceableItem& WithAttributes(const Aws::Vector<ReplaceableAttribute>& value) { SetAttributes(value); return *this;}
+
+    /**
+     * The list of attributes for a replaceable item.
+     */
+    inline ReplaceableItem& WithAttributes(Aws::Vector<ReplaceableAttribute>&& value) { SetAttributes(std::move(value)); return *this;}
+
+    /**
+     * The list of attributes for a replaceable item.
+     */
+    inline ReplaceableItem& AddAttributes(const ReplaceableAttribute& value) { m_attributesHasBeenSet = true; m_attributes.push_back(value); return *this; }
+
+    /**
+     * The list of attributes for a replaceable item.
+     */
+    inline ReplaceableItem& AddAttributes(ReplaceableAttribute&& value) { m_attributesHasBeenSet = true; m_attributes.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    Aws::Vector<ReplaceableAttribute> m_attributes;
+    bool m_attributesHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/RequestTimeout.h

@@ -0,0 +1,61 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   * <p>A timeout occurred when attempting to query the specified domain with
+   * specified query expression.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/RequestTimeout">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SIMPLEDB_API RequestTimeout
+  {
+  public:
+    RequestTimeout();
+    RequestTimeout(const Aws::Utils::Xml::XmlNode& xmlNode);
+    RequestTimeout& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    
+    inline double GetBoxUsage() const{ return m_boxUsage; }
+
+    
+    inline bool BoxUsageHasBeenSet() const { return m_boxUsageHasBeenSet; }
+
+    
+    inline void SetBoxUsage(double value) { m_boxUsageHasBeenSet = true; m_boxUsage = value; }
+
+    
+    inline RequestTimeout& WithBoxUsage(double value) { SetBoxUsage(value); return *this;}
+
+  private:
+
+    double m_boxUsage;
+    bool m_boxUsageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/ResponseMetadata.h

@@ -0,0 +1,69 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace SimpleDB
+{
+namespace Model
+{
+
+  class AWS_SIMPLEDB_API ResponseMetadata
+  {
+  public:
+    ResponseMetadata();
+    ResponseMetadata(const Aws::Utils::Xml::XmlNode& xmlNode);
+    ResponseMetadata& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    
+    inline const Aws::String& GetRequestId() const{ return m_requestId; }
+
+    
+    inline bool RequestIdHasBeenSet() const { return m_requestIdHasBeenSet; }
+
+    
+    inline void SetRequestId(const Aws::String& value) { m_requestIdHasBeenSet = true; m_requestId = value; }
+
+    
+    inline void SetRequestId(Aws::String&& value) { m_requestIdHasBeenSet = true; m_requestId = std::move(value); }
+
+    
+    inline void SetRequestId(const char* value) { m_requestIdHasBeenSet = true; m_requestId.assign(value); }
+
+    
+    inline ResponseMetadata& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
+
+    
+    inline ResponseMetadata& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
+
+    
+    inline ResponseMetadata& WithRequestId(const char* value) { SetRequestId(value); return *this;}
+
+  private:
+
+    Aws::String m_requestId;
+    bool m_requestIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/SelectRequest.h

@@ -0,0 +1,175 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/sdb/SimpleDBRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SIMPLEDB_API SelectRequest : public SimpleDBRequest
+  {
+  public:
+    SelectRequest();
+
+    // 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 "Select"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * The expression used to query the domain.
+     */
+    inline const Aws::String& GetSelectExpression() const{ return m_selectExpression; }
+
+    /**
+     * The expression used to query the domain.
+     */
+    inline bool SelectExpressionHasBeenSet() const { return m_selectExpressionHasBeenSet; }
+
+    /**
+     * The expression used to query the domain.
+     */
+    inline void SetSelectExpression(const Aws::String& value) { m_selectExpressionHasBeenSet = true; m_selectExpression = value; }
+
+    /**
+     * The expression used to query the domain.
+     */
+    inline void SetSelectExpression(Aws::String&& value) { m_selectExpressionHasBeenSet = true; m_selectExpression = std::move(value); }
+
+    /**
+     * The expression used to query the domain.
+     */
+    inline void SetSelectExpression(const char* value) { m_selectExpressionHasBeenSet = true; m_selectExpression.assign(value); }
+
+    /**
+     * The expression used to query the domain.
+     */
+    inline SelectRequest& WithSelectExpression(const Aws::String& value) { SetSelectExpression(value); return *this;}
+
+    /**
+     * The expression used to query the domain.
+     */
+    inline SelectRequest& WithSelectExpression(Aws::String&& value) { SetSelectExpression(std::move(value)); return *this;}
+
+    /**
+     * The expression used to query the domain.
+     */
+    inline SelectRequest& WithSelectExpression(const char* value) { SetSelectExpression(value); return *this;}
+
+
+    /**
+     * A string informing Amazon SimpleDB where to start the next list of
+     * <code>ItemNames</code>.
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * A string informing Amazon SimpleDB where to start the next list of
+     * <code>ItemNames</code>.
+     */
+    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+
+    /**
+     * A string informing Amazon SimpleDB where to start the next list of
+     * <code>ItemNames</code>.
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
+
+    /**
+     * A string informing Amazon SimpleDB where to start the next list of
+     * <code>ItemNames</code>.
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
+
+    /**
+     * A string informing Amazon SimpleDB where to start the next list of
+     * <code>ItemNames</code>.
+     */
+    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
+
+    /**
+     * A string informing Amazon SimpleDB where to start the next list of
+     * <code>ItemNames</code>.
+     */
+    inline SelectRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * A string informing Amazon SimpleDB where to start the next list of
+     * <code>ItemNames</code>.
+     */
+    inline SelectRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * A string informing Amazon SimpleDB where to start the next list of
+     * <code>ItemNames</code>.
+     */
+    inline SelectRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * Determines whether or not strong consistency should be enforced when data is
+     * read from SimpleDB. If <code>true</code>, any data previously written to
+     * SimpleDB will be returned. Otherwise, results will be consistent eventually, and
+     * the client may not see data that was written immediately before your read.
+     */
+    inline bool GetConsistentRead() const{ return m_consistentRead; }
+
+    /**
+     * Determines whether or not strong consistency should be enforced when data is
+     * read from SimpleDB. If <code>true</code>, any data previously written to
+     * SimpleDB will be returned. Otherwise, results will be consistent eventually, and
+     * the client may not see data that was written immediately before your read.
+     */
+    inline bool ConsistentReadHasBeenSet() const { return m_consistentReadHasBeenSet; }
+
+    /**
+     * Determines whether or not strong consistency should be enforced when data is
+     * read from SimpleDB. If <code>true</code>, any data previously written to
+     * SimpleDB will be returned. Otherwise, results will be consistent eventually, and
+     * the client may not see data that was written immediately before your read.
+     */
+    inline void SetConsistentRead(bool value) { m_consistentReadHasBeenSet = true; m_consistentRead = value; }
+
+    /**
+     * Determines whether or not strong consistency should be enforced when data is
+     * read from SimpleDB. If <code>true</code>, any data previously written to
+     * SimpleDB will be returned. Otherwise, results will be consistent eventually, and
+     * the client may not see data that was written immediately before your read.
+     */
+    inline SelectRequest& WithConsistentRead(bool value) { SetConsistentRead(value); return *this;}
+
+  private:
+
+    Aws::String m_selectExpression;
+    bool m_selectExpressionHasBeenSet;
+
+    Aws::String m_nextToken;
+    bool m_nextTokenHasBeenSet;
+
+    bool m_consistentRead;
+    bool m_consistentReadHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/SelectResult.h

@@ -0,0 +1,150 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/sdb/model/ResponseMetadata.h>
+#include <aws/sdb/model/Item.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace SimpleDB
+{
+namespace Model
+{
+  class AWS_SIMPLEDB_API SelectResult
+  {
+  public:
+    SelectResult();
+    SelectResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    SelectResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    /**
+     * A list of items that match the select expression.
+     */
+    inline const Aws::Vector<Item>& GetItems() const{ return m_items; }
+
+    /**
+     * A list of items that match the select expression.
+     */
+    inline void SetItems(const Aws::Vector<Item>& value) { m_items = value; }
+
+    /**
+     * A list of items that match the select expression.
+     */
+    inline void SetItems(Aws::Vector<Item>&& value) { m_items = std::move(value); }
+
+    /**
+     * A list of items that match the select expression.
+     */
+    inline SelectResult& WithItems(const Aws::Vector<Item>& value) { SetItems(value); return *this;}
+
+    /**
+     * A list of items that match the select expression.
+     */
+    inline SelectResult& WithItems(Aws::Vector<Item>&& value) { SetItems(std::move(value)); return *this;}
+
+    /**
+     * A list of items that match the select expression.
+     */
+    inline SelectResult& AddItems(const Item& value) { m_items.push_back(value); return *this; }
+
+    /**
+     * A list of items that match the select expression.
+     */
+    inline SelectResult& AddItems(Item&& value) { m_items.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * An opaque token indicating that more items than <code>MaxNumberOfItems</code>
+     * were matched, the response size exceeded 1 megabyte, or the execution time
+     * exceeded 5 seconds.
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * An opaque token indicating that more items than <code>MaxNumberOfItems</code>
+     * were matched, the response size exceeded 1 megabyte, or the execution time
+     * exceeded 5 seconds.
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
+
+    /**
+     * An opaque token indicating that more items than <code>MaxNumberOfItems</code>
+     * were matched, the response size exceeded 1 megabyte, or the execution time
+     * exceeded 5 seconds.
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
+
+    /**
+     * An opaque token indicating that more items than <code>MaxNumberOfItems</code>
+     * were matched, the response size exceeded 1 megabyte, or the execution time
+     * exceeded 5 seconds.
+     */
+    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
+
+    /**
+     * An opaque token indicating that more items than <code>MaxNumberOfItems</code>
+     * were matched, the response size exceeded 1 megabyte, or the execution time
+     * exceeded 5 seconds.
+     */
+    inline SelectResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * An opaque token indicating that more items than <code>MaxNumberOfItems</code>
+     * were matched, the response size exceeded 1 megabyte, or the execution time
+     * exceeded 5 seconds.
+     */
+    inline SelectResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * An opaque token indicating that more items than <code>MaxNumberOfItems</code>
+     * were matched, the response size exceeded 1 megabyte, or the execution time
+     * exceeded 5 seconds.
+     */
+    inline SelectResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline SelectResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline SelectResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    Aws::Vector<Item> m_items;
+
+    Aws::String m_nextToken;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/TooManyRequestedAttributes.h

@@ -0,0 +1,60 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   * <p>Too many attributes requested.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/TooManyRequestedAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SIMPLEDB_API TooManyRequestedAttributes
+  {
+  public:
+    TooManyRequestedAttributes();
+    TooManyRequestedAttributes(const Aws::Utils::Xml::XmlNode& xmlNode);
+    TooManyRequestedAttributes& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    
+    inline double GetBoxUsage() const{ return m_boxUsage; }
+
+    
+    inline bool BoxUsageHasBeenSet() const { return m_boxUsageHasBeenSet; }
+
+    
+    inline void SetBoxUsage(double value) { m_boxUsageHasBeenSet = true; m_boxUsage = value; }
+
+    
+    inline TooManyRequestedAttributes& WithBoxUsage(double value) { SetBoxUsage(value); return *this;}
+
+  private:
+
+    double m_boxUsage;
+    bool m_boxUsageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-sdb/include/aws/sdb/model/UpdateCondition.h

@@ -0,0 +1,186 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sdb/SimpleDB_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace SimpleDB
+{
+namespace Model
+{
+
+  /**
+   * <p> Specifies the conditions under which data should be updated. If an update
+   * condition is specified for a request, the data will only be updated if the
+   * condition is satisfied. For example, if an attribute with a specific name and
+   * value exists, or if a specific attribute doesn't exist. </p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sdb-2009-04-15/UpdateCondition">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SIMPLEDB_API UpdateCondition
+  {
+  public:
+    UpdateCondition();
+    UpdateCondition(const Aws::Utils::Xml::XmlNode& xmlNode);
+    UpdateCondition& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    /**
+     * <p>The name of the attribute involved in the condition.</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>The name of the attribute involved in the condition.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>The name of the attribute involved in the condition.</p>
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>The name of the attribute involved in the condition.</p>
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>The name of the attribute involved in the condition.</p>
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * <p>The name of the attribute involved in the condition.</p>
+     */
+    inline UpdateCondition& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>The name of the attribute involved in the condition.</p>
+     */
+    inline UpdateCondition& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the attribute involved in the condition.</p>
+     */
+    inline UpdateCondition& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * <p>The value of an attribute. This value can only be specified when the
+     * <code>Exists</code> parameter is equal to <code>true</code>.</p>
+     */
+    inline const Aws::String& GetValue() const{ return m_value; }
+
+    /**
+     * <p>The value of an attribute. This value can only be specified when the
+     * <code>Exists</code> parameter is equal to <code>true</code>.</p>
+     */
+    inline bool ValueHasBeenSet() const { return m_valueHasBeenSet; }
+
+    /**
+     * <p>The value of an attribute. This value can only be specified when the
+     * <code>Exists</code> parameter is equal to <code>true</code>.</p>
+     */
+    inline void SetValue(const Aws::String& value) { m_valueHasBeenSet = true; m_value = value; }
+
+    /**
+     * <p>The value of an attribute. This value can only be specified when the
+     * <code>Exists</code> parameter is equal to <code>true</code>.</p>
+     */
+    inline void SetValue(Aws::String&& value) { m_valueHasBeenSet = true; m_value = std::move(value); }
+
+    /**
+     * <p>The value of an attribute. This value can only be specified when the
+     * <code>Exists</code> parameter is equal to <code>true</code>.</p>
+     */
+    inline void SetValue(const char* value) { m_valueHasBeenSet = true; m_value.assign(value); }
+
+    /**
+     * <p>The value of an attribute. This value can only be specified when the
+     * <code>Exists</code> parameter is equal to <code>true</code>.</p>
+     */
+    inline UpdateCondition& WithValue(const Aws::String& value) { SetValue(value); return *this;}
+
+    /**
+     * <p>The value of an attribute. This value can only be specified when the
+     * <code>Exists</code> parameter is equal to <code>true</code>.</p>
+     */
+    inline UpdateCondition& WithValue(Aws::String&& value) { SetValue(std::move(value)); return *this;}
+
+    /**
+     * <p>The value of an attribute. This value can only be specified when the
+     * <code>Exists</code> parameter is equal to <code>true</code>.</p>
+     */
+    inline UpdateCondition& WithValue(const char* value) { SetValue(value); return *this;}
+
+
+    /**
+     * <p>A value specifying whether or not the specified attribute must exist with the
+     * specified value in order for the update condition to be satisfied. Specify
+     * <code>true</code> if the attribute must exist for the update condition to be
+     * satisfied. Specify <code>false</code> if the attribute should not exist in order
+     * for the update condition to be satisfied.</p>
+     */
+    inline bool GetExists() const{ return m_exists; }
+
+    /**
+     * <p>A value specifying whether or not the specified attribute must exist with the
+     * specified value in order for the update condition to be satisfied. Specify
+     * <code>true</code> if the attribute must exist for the update condition to be
+     * satisfied. Specify <code>false</code> if the attribute should not exist in order
+     * for the update condition to be satisfied.</p>
+     */
+    inline bool ExistsHasBeenSet() const { return m_existsHasBeenSet; }
+
+    /**
+     * <p>A value specifying whether or not the specified attribute must exist with the
+     * specified value in order for the update condition to be satisfied. Specify
+     * <code>true</code> if the attribute must exist for the update condition to be
+     * satisfied. Specify <code>false</code> if the attribute should not exist in order
+     * for the update condition to be satisfied.</p>
+     */
+    inline void SetExists(bool value) { m_existsHasBeenSet = true; m_exists = value; }
+
+    /**
+     * <p>A value specifying whether or not the specified attribute must exist with the
+     * specified value in order for the update condition to be satisfied. Specify
+     * <code>true</code> if the attribute must exist for the update condition to be
+     * satisfied. Specify <code>false</code> if the attribute should not exist in order
+     * for the update condition to be satisfied.</p>
+     */
+    inline UpdateCondition& WithExists(bool value) { SetExists(value); return *this;}
+
+  private:
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    Aws::String m_value;
+    bool m_valueHasBeenSet;
+
+    bool m_exists;
+    bool m_existsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SimpleDB
+} // namespace Aws