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

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/DAXClient.h

@@ -0,0 +1,889 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/DAXErrors.h>
+#include <aws/core/client/AWSError.h>
+#include <aws/core/client/ClientConfiguration.h>
+#include <aws/core/client/AWSClient.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/dax/model/CreateClusterResult.h>
+#include <aws/dax/model/CreateParameterGroupResult.h>
+#include <aws/dax/model/CreateSubnetGroupResult.h>
+#include <aws/dax/model/DecreaseReplicationFactorResult.h>
+#include <aws/dax/model/DeleteClusterResult.h>
+#include <aws/dax/model/DeleteParameterGroupResult.h>
+#include <aws/dax/model/DeleteSubnetGroupResult.h>
+#include <aws/dax/model/DescribeClustersResult.h>
+#include <aws/dax/model/DescribeDefaultParametersResult.h>
+#include <aws/dax/model/DescribeEventsResult.h>
+#include <aws/dax/model/DescribeParameterGroupsResult.h>
+#include <aws/dax/model/DescribeParametersResult.h>
+#include <aws/dax/model/DescribeSubnetGroupsResult.h>
+#include <aws/dax/model/IncreaseReplicationFactorResult.h>
+#include <aws/dax/model/ListTagsResult.h>
+#include <aws/dax/model/RebootNodeResult.h>
+#include <aws/dax/model/TagResourceResult.h>
+#include <aws/dax/model/UntagResourceResult.h>
+#include <aws/dax/model/UpdateClusterResult.h>
+#include <aws/dax/model/UpdateParameterGroupResult.h>
+#include <aws/dax/model/UpdateSubnetGroupResult.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 Utils
+
+namespace Auth
+{
+  class AWSCredentials;
+  class AWSCredentialsProvider;
+} // namespace Auth
+
+namespace Client
+{
+  class RetryStrategy;
+} // namespace Client
+
+namespace DAX
+{
+
+namespace Model
+{
+        class CreateClusterRequest;
+        class CreateParameterGroupRequest;
+        class CreateSubnetGroupRequest;
+        class DecreaseReplicationFactorRequest;
+        class DeleteClusterRequest;
+        class DeleteParameterGroupRequest;
+        class DeleteSubnetGroupRequest;
+        class DescribeClustersRequest;
+        class DescribeDefaultParametersRequest;
+        class DescribeEventsRequest;
+        class DescribeParameterGroupsRequest;
+        class DescribeParametersRequest;
+        class DescribeSubnetGroupsRequest;
+        class IncreaseReplicationFactorRequest;
+        class ListTagsRequest;
+        class RebootNodeRequest;
+        class TagResourceRequest;
+        class UntagResourceRequest;
+        class UpdateClusterRequest;
+        class UpdateParameterGroupRequest;
+        class UpdateSubnetGroupRequest;
+
+        typedef Aws::Utils::Outcome<CreateClusterResult, DAXError> CreateClusterOutcome;
+        typedef Aws::Utils::Outcome<CreateParameterGroupResult, DAXError> CreateParameterGroupOutcome;
+        typedef Aws::Utils::Outcome<CreateSubnetGroupResult, DAXError> CreateSubnetGroupOutcome;
+        typedef Aws::Utils::Outcome<DecreaseReplicationFactorResult, DAXError> DecreaseReplicationFactorOutcome;
+        typedef Aws::Utils::Outcome<DeleteClusterResult, DAXError> DeleteClusterOutcome;
+        typedef Aws::Utils::Outcome<DeleteParameterGroupResult, DAXError> DeleteParameterGroupOutcome;
+        typedef Aws::Utils::Outcome<DeleteSubnetGroupResult, DAXError> DeleteSubnetGroupOutcome;
+        typedef Aws::Utils::Outcome<DescribeClustersResult, DAXError> DescribeClustersOutcome;
+        typedef Aws::Utils::Outcome<DescribeDefaultParametersResult, DAXError> DescribeDefaultParametersOutcome;
+        typedef Aws::Utils::Outcome<DescribeEventsResult, DAXError> DescribeEventsOutcome;
+        typedef Aws::Utils::Outcome<DescribeParameterGroupsResult, DAXError> DescribeParameterGroupsOutcome;
+        typedef Aws::Utils::Outcome<DescribeParametersResult, DAXError> DescribeParametersOutcome;
+        typedef Aws::Utils::Outcome<DescribeSubnetGroupsResult, DAXError> DescribeSubnetGroupsOutcome;
+        typedef Aws::Utils::Outcome<IncreaseReplicationFactorResult, DAXError> IncreaseReplicationFactorOutcome;
+        typedef Aws::Utils::Outcome<ListTagsResult, DAXError> ListTagsOutcome;
+        typedef Aws::Utils::Outcome<RebootNodeResult, DAXError> RebootNodeOutcome;
+        typedef Aws::Utils::Outcome<TagResourceResult, DAXError> TagResourceOutcome;
+        typedef Aws::Utils::Outcome<UntagResourceResult, DAXError> UntagResourceOutcome;
+        typedef Aws::Utils::Outcome<UpdateClusterResult, DAXError> UpdateClusterOutcome;
+        typedef Aws::Utils::Outcome<UpdateParameterGroupResult, DAXError> UpdateParameterGroupOutcome;
+        typedef Aws::Utils::Outcome<UpdateSubnetGroupResult, DAXError> UpdateSubnetGroupOutcome;
+
+        typedef std::future<CreateClusterOutcome> CreateClusterOutcomeCallable;
+        typedef std::future<CreateParameterGroupOutcome> CreateParameterGroupOutcomeCallable;
+        typedef std::future<CreateSubnetGroupOutcome> CreateSubnetGroupOutcomeCallable;
+        typedef std::future<DecreaseReplicationFactorOutcome> DecreaseReplicationFactorOutcomeCallable;
+        typedef std::future<DeleteClusterOutcome> DeleteClusterOutcomeCallable;
+        typedef std::future<DeleteParameterGroupOutcome> DeleteParameterGroupOutcomeCallable;
+        typedef std::future<DeleteSubnetGroupOutcome> DeleteSubnetGroupOutcomeCallable;
+        typedef std::future<DescribeClustersOutcome> DescribeClustersOutcomeCallable;
+        typedef std::future<DescribeDefaultParametersOutcome> DescribeDefaultParametersOutcomeCallable;
+        typedef std::future<DescribeEventsOutcome> DescribeEventsOutcomeCallable;
+        typedef std::future<DescribeParameterGroupsOutcome> DescribeParameterGroupsOutcomeCallable;
+        typedef std::future<DescribeParametersOutcome> DescribeParametersOutcomeCallable;
+        typedef std::future<DescribeSubnetGroupsOutcome> DescribeSubnetGroupsOutcomeCallable;
+        typedef std::future<IncreaseReplicationFactorOutcome> IncreaseReplicationFactorOutcomeCallable;
+        typedef std::future<ListTagsOutcome> ListTagsOutcomeCallable;
+        typedef std::future<RebootNodeOutcome> RebootNodeOutcomeCallable;
+        typedef std::future<TagResourceOutcome> TagResourceOutcomeCallable;
+        typedef std::future<UntagResourceOutcome> UntagResourceOutcomeCallable;
+        typedef std::future<UpdateClusterOutcome> UpdateClusterOutcomeCallable;
+        typedef std::future<UpdateParameterGroupOutcome> UpdateParameterGroupOutcomeCallable;
+        typedef std::future<UpdateSubnetGroupOutcome> UpdateSubnetGroupOutcomeCallable;
+} // namespace Model
+
+  class DAXClient;
+
+    typedef std::function<void(const DAXClient*, const Model::CreateClusterRequest&, const Model::CreateClusterOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateClusterResponseReceivedHandler;
+    typedef std::function<void(const DAXClient*, const Model::CreateParameterGroupRequest&, const Model::CreateParameterGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateParameterGroupResponseReceivedHandler;
+    typedef std::function<void(const DAXClient*, const Model::CreateSubnetGroupRequest&, const Model::CreateSubnetGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateSubnetGroupResponseReceivedHandler;
+    typedef std::function<void(const DAXClient*, const Model::DecreaseReplicationFactorRequest&, const Model::DecreaseReplicationFactorOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DecreaseReplicationFactorResponseReceivedHandler;
+    typedef std::function<void(const DAXClient*, const Model::DeleteClusterRequest&, const Model::DeleteClusterOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteClusterResponseReceivedHandler;
+    typedef std::function<void(const DAXClient*, const Model::DeleteParameterGroupRequest&, const Model::DeleteParameterGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteParameterGroupResponseReceivedHandler;
+    typedef std::function<void(const DAXClient*, const Model::DeleteSubnetGroupRequest&, const Model::DeleteSubnetGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteSubnetGroupResponseReceivedHandler;
+    typedef std::function<void(const DAXClient*, const Model::DescribeClustersRequest&, const Model::DescribeClustersOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeClustersResponseReceivedHandler;
+    typedef std::function<void(const DAXClient*, const Model::DescribeDefaultParametersRequest&, const Model::DescribeDefaultParametersOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeDefaultParametersResponseReceivedHandler;
+    typedef std::function<void(const DAXClient*, const Model::DescribeEventsRequest&, const Model::DescribeEventsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeEventsResponseReceivedHandler;
+    typedef std::function<void(const DAXClient*, const Model::DescribeParameterGroupsRequest&, const Model::DescribeParameterGroupsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeParameterGroupsResponseReceivedHandler;
+    typedef std::function<void(const DAXClient*, const Model::DescribeParametersRequest&, const Model::DescribeParametersOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeParametersResponseReceivedHandler;
+    typedef std::function<void(const DAXClient*, const Model::DescribeSubnetGroupsRequest&, const Model::DescribeSubnetGroupsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeSubnetGroupsResponseReceivedHandler;
+    typedef std::function<void(const DAXClient*, const Model::IncreaseReplicationFactorRequest&, const Model::IncreaseReplicationFactorOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > IncreaseReplicationFactorResponseReceivedHandler;
+    typedef std::function<void(const DAXClient*, const Model::ListTagsRequest&, const Model::ListTagsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListTagsResponseReceivedHandler;
+    typedef std::function<void(const DAXClient*, const Model::RebootNodeRequest&, const Model::RebootNodeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RebootNodeResponseReceivedHandler;
+    typedef std::function<void(const DAXClient*, const Model::TagResourceRequest&, const Model::TagResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > TagResourceResponseReceivedHandler;
+    typedef std::function<void(const DAXClient*, const Model::UntagResourceRequest&, const Model::UntagResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UntagResourceResponseReceivedHandler;
+    typedef std::function<void(const DAXClient*, const Model::UpdateClusterRequest&, const Model::UpdateClusterOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateClusterResponseReceivedHandler;
+    typedef std::function<void(const DAXClient*, const Model::UpdateParameterGroupRequest&, const Model::UpdateParameterGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateParameterGroupResponseReceivedHandler;
+    typedef std::function<void(const DAXClient*, const Model::UpdateSubnetGroupRequest&, const Model::UpdateSubnetGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateSubnetGroupResponseReceivedHandler;
+
+  /**
+   * <p>DAX is a managed caching service engineered for Amazon DynamoDB. DAX
+   * dramatically speeds up database reads by caching frequently-accessed data from
+   * DynamoDB, so applications can access that data with sub-millisecond latency. You
+   * can create a DAX cluster easily, using the AWS Management Console. With a few
+   * simple modifications to your code, your application can begin taking advantage
+   * of the DAX cluster and realize significant improvements in read performance.</p>
+   */
+  class AWS_DAX_API DAXClient : public Aws::Client::AWSJsonClient
+  {
+    public:
+      typedef Aws::Client::AWSJsonClient 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.
+        */
+        DAXClient(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.
+        */
+        DAXClient(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
+        */
+        DAXClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
+            const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());
+
+        virtual ~DAXClient();
+
+
+        /**
+         * <p>Creates a DAX cluster. All nodes in the cluster run the same DAX caching
+         * software.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/CreateCluster">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::CreateClusterOutcome CreateCluster(const Model::CreateClusterRequest& request) const;
+
+        /**
+         * <p>Creates a DAX cluster. All nodes in the cluster run the same DAX caching
+         * software.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/CreateCluster">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::CreateClusterOutcomeCallable CreateClusterCallable(const Model::CreateClusterRequest& request) const;
+
+        /**
+         * <p>Creates a DAX cluster. All nodes in the cluster run the same DAX caching
+         * software.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/CreateCluster">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void CreateClusterAsync(const Model::CreateClusterRequest& request, const CreateClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Creates a new parameter group. A parameter group is a collection of
+         * parameters that you apply to all of the nodes in a DAX cluster.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/CreateParameterGroup">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::CreateParameterGroupOutcome CreateParameterGroup(const Model::CreateParameterGroupRequest& request) const;
+
+        /**
+         * <p>Creates a new parameter group. A parameter group is a collection of
+         * parameters that you apply to all of the nodes in a DAX cluster.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/CreateParameterGroup">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::CreateParameterGroupOutcomeCallable CreateParameterGroupCallable(const Model::CreateParameterGroupRequest& request) const;
+
+        /**
+         * <p>Creates a new parameter group. A parameter group is a collection of
+         * parameters that you apply to all of the nodes in a DAX cluster.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/CreateParameterGroup">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void CreateParameterGroupAsync(const Model::CreateParameterGroupRequest& request, const CreateParameterGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Creates a new subnet group.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/CreateSubnetGroup">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::CreateSubnetGroupOutcome CreateSubnetGroup(const Model::CreateSubnetGroupRequest& request) const;
+
+        /**
+         * <p>Creates a new subnet group.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/CreateSubnetGroup">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::CreateSubnetGroupOutcomeCallable CreateSubnetGroupCallable(const Model::CreateSubnetGroupRequest& request) const;
+
+        /**
+         * <p>Creates a new subnet group.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/CreateSubnetGroup">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void CreateSubnetGroupAsync(const Model::CreateSubnetGroupRequest& request, const CreateSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Removes one or more nodes from a DAX cluster.</p>  <p>You cannot use
+         * <code>DecreaseReplicationFactor</code> to remove the last node in a DAX cluster.
+         * If you need to do this, use <code>DeleteCluster</code> instead.</p>
+         * <p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DecreaseReplicationFactor">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DecreaseReplicationFactorOutcome DecreaseReplicationFactor(const Model::DecreaseReplicationFactorRequest& request) const;
+
+        /**
+         * <p>Removes one or more nodes from a DAX cluster.</p>  <p>You cannot use
+         * <code>DecreaseReplicationFactor</code> to remove the last node in a DAX cluster.
+         * If you need to do this, use <code>DeleteCluster</code> instead.</p>
+         * <p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DecreaseReplicationFactor">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DecreaseReplicationFactorOutcomeCallable DecreaseReplicationFactorCallable(const Model::DecreaseReplicationFactorRequest& request) const;
+
+        /**
+         * <p>Removes one or more nodes from a DAX cluster.</p>  <p>You cannot use
+         * <code>DecreaseReplicationFactor</code> to remove the last node in a DAX cluster.
+         * If you need to do this, use <code>DeleteCluster</code> instead.</p>
+         * <p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DecreaseReplicationFactor">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DecreaseReplicationFactorAsync(const Model::DecreaseReplicationFactorRequest& request, const DecreaseReplicationFactorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Deletes a previously provisioned DAX cluster. <i>DeleteCluster</i> deletes
+         * all associated nodes, node endpoints and the DAX cluster itself. When you
+         * receive a successful response from this action, DAX immediately begins deleting
+         * the cluster; you cannot cancel or revert this action.</p><p><h3>See Also:</h3>  
+         * <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DeleteCluster">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DeleteClusterOutcome DeleteCluster(const Model::DeleteClusterRequest& request) const;
+
+        /**
+         * <p>Deletes a previously provisioned DAX cluster. <i>DeleteCluster</i> deletes
+         * all associated nodes, node endpoints and the DAX cluster itself. When you
+         * receive a successful response from this action, DAX immediately begins deleting
+         * the cluster; you cannot cancel or revert this action.</p><p><h3>See Also:</h3>  
+         * <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DeleteCluster">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DeleteClusterOutcomeCallable DeleteClusterCallable(const Model::DeleteClusterRequest& request) const;
+
+        /**
+         * <p>Deletes a previously provisioned DAX cluster. <i>DeleteCluster</i> deletes
+         * all associated nodes, node endpoints and the DAX cluster itself. When you
+         * receive a successful response from this action, DAX immediately begins deleting
+         * the cluster; you cannot cancel or revert this action.</p><p><h3>See Also:</h3>  
+         * <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DeleteCluster">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DeleteClusterAsync(const Model::DeleteClusterRequest& request, const DeleteClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Deletes the specified parameter group. You cannot delete a parameter group if
+         * it is associated with any DAX clusters.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DeleteParameterGroup">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DeleteParameterGroupOutcome DeleteParameterGroup(const Model::DeleteParameterGroupRequest& request) const;
+
+        /**
+         * <p>Deletes the specified parameter group. You cannot delete a parameter group if
+         * it is associated with any DAX clusters.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DeleteParameterGroup">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DeleteParameterGroupOutcomeCallable DeleteParameterGroupCallable(const Model::DeleteParameterGroupRequest& request) const;
+
+        /**
+         * <p>Deletes the specified parameter group. You cannot delete a parameter group if
+         * it is associated with any DAX clusters.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DeleteParameterGroup">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DeleteParameterGroupAsync(const Model::DeleteParameterGroupRequest& request, const DeleteParameterGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Deletes a subnet group.</p>  <p>You cannot delete a subnet group if it
+         * is associated with any DAX clusters.</p> <p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DeleteSubnetGroup">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DeleteSubnetGroupOutcome DeleteSubnetGroup(const Model::DeleteSubnetGroupRequest& request) const;
+
+        /**
+         * <p>Deletes a subnet group.</p>  <p>You cannot delete a subnet group if it
+         * is associated with any DAX clusters.</p> <p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DeleteSubnetGroup">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DeleteSubnetGroupOutcomeCallable DeleteSubnetGroupCallable(const Model::DeleteSubnetGroupRequest& request) const;
+
+        /**
+         * <p>Deletes a subnet group.</p>  <p>You cannot delete a subnet group if it
+         * is associated with any DAX clusters.</p> <p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DeleteSubnetGroup">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DeleteSubnetGroupAsync(const Model::DeleteSubnetGroupRequest& request, const DeleteSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Returns information about all provisioned DAX clusters if no cluster
+         * identifier is specified, or about a specific DAX cluster if a cluster identifier
+         * is supplied.</p> <p>If the cluster is in the CREATING state, only cluster level
+         * information will be displayed until all of the nodes are successfully
+         * provisioned.</p> <p>If the cluster is in the DELETING state, only cluster level
+         * information will be displayed.</p> <p>If nodes are currently being added to the
+         * DAX cluster, node endpoint information and creation time for the additional
+         * nodes will not be displayed until they are completely provisioned. When the DAX
+         * cluster state is <i>available</i>, the cluster is ready for use.</p> <p>If nodes
+         * are currently being removed from the DAX cluster, no endpoint information for
+         * the removed nodes is displayed.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DescribeClusters">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DescribeClustersOutcome DescribeClusters(const Model::DescribeClustersRequest& request) const;
+
+        /**
+         * <p>Returns information about all provisioned DAX clusters if no cluster
+         * identifier is specified, or about a specific DAX cluster if a cluster identifier
+         * is supplied.</p> <p>If the cluster is in the CREATING state, only cluster level
+         * information will be displayed until all of the nodes are successfully
+         * provisioned.</p> <p>If the cluster is in the DELETING state, only cluster level
+         * information will be displayed.</p> <p>If nodes are currently being added to the
+         * DAX cluster, node endpoint information and creation time for the additional
+         * nodes will not be displayed until they are completely provisioned. When the DAX
+         * cluster state is <i>available</i>, the cluster is ready for use.</p> <p>If nodes
+         * are currently being removed from the DAX cluster, no endpoint information for
+         * the removed nodes is displayed.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DescribeClusters">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DescribeClustersOutcomeCallable DescribeClustersCallable(const Model::DescribeClustersRequest& request) const;
+
+        /**
+         * <p>Returns information about all provisioned DAX clusters if no cluster
+         * identifier is specified, or about a specific DAX cluster if a cluster identifier
+         * is supplied.</p> <p>If the cluster is in the CREATING state, only cluster level
+         * information will be displayed until all of the nodes are successfully
+         * provisioned.</p> <p>If the cluster is in the DELETING state, only cluster level
+         * information will be displayed.</p> <p>If nodes are currently being added to the
+         * DAX cluster, node endpoint information and creation time for the additional
+         * nodes will not be displayed until they are completely provisioned. When the DAX
+         * cluster state is <i>available</i>, the cluster is ready for use.</p> <p>If nodes
+         * are currently being removed from the DAX cluster, no endpoint information for
+         * the removed nodes is displayed.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DescribeClusters">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DescribeClustersAsync(const Model::DescribeClustersRequest& request, const DescribeClustersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Returns the default system parameter information for the DAX caching
+         * software.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DescribeDefaultParameters">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DescribeDefaultParametersOutcome DescribeDefaultParameters(const Model::DescribeDefaultParametersRequest& request) const;
+
+        /**
+         * <p>Returns the default system parameter information for the DAX caching
+         * software.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DescribeDefaultParameters">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DescribeDefaultParametersOutcomeCallable DescribeDefaultParametersCallable(const Model::DescribeDefaultParametersRequest& request) const;
+
+        /**
+         * <p>Returns the default system parameter information for the DAX caching
+         * software.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DescribeDefaultParameters">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DescribeDefaultParametersAsync(const Model::DescribeDefaultParametersRequest& request, const DescribeDefaultParametersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Returns events related to DAX clusters and parameter groups. You can obtain
+         * events specific to a particular DAX cluster or parameter group by providing the
+         * name as a parameter.</p> <p>By default, only the events occurring within the
+         * last 24 hours are returned; however, you can retrieve up to 14 days' worth of
+         * events if necessary.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DescribeEvents">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DescribeEventsOutcome DescribeEvents(const Model::DescribeEventsRequest& request) const;
+
+        /**
+         * <p>Returns events related to DAX clusters and parameter groups. You can obtain
+         * events specific to a particular DAX cluster or parameter group by providing the
+         * name as a parameter.</p> <p>By default, only the events occurring within the
+         * last 24 hours are returned; however, you can retrieve up to 14 days' worth of
+         * events if necessary.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DescribeEvents">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DescribeEventsOutcomeCallable DescribeEventsCallable(const Model::DescribeEventsRequest& request) const;
+
+        /**
+         * <p>Returns events related to DAX clusters and parameter groups. You can obtain
+         * events specific to a particular DAX cluster or parameter group by providing the
+         * name as a parameter.</p> <p>By default, only the events occurring within the
+         * last 24 hours are returned; however, you can retrieve up to 14 days' worth of
+         * events if necessary.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DescribeEvents">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DescribeEventsAsync(const Model::DescribeEventsRequest& request, const DescribeEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Returns a list of parameter group descriptions. If a parameter group name is
+         * specified, the list will contain only the descriptions for that
+         * group.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DescribeParameterGroups">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DescribeParameterGroupsOutcome DescribeParameterGroups(const Model::DescribeParameterGroupsRequest& request) const;
+
+        /**
+         * <p>Returns a list of parameter group descriptions. If a parameter group name is
+         * specified, the list will contain only the descriptions for that
+         * group.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DescribeParameterGroups">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DescribeParameterGroupsOutcomeCallable DescribeParameterGroupsCallable(const Model::DescribeParameterGroupsRequest& request) const;
+
+        /**
+         * <p>Returns a list of parameter group descriptions. If a parameter group name is
+         * specified, the list will contain only the descriptions for that
+         * group.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DescribeParameterGroups">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DescribeParameterGroupsAsync(const Model::DescribeParameterGroupsRequest& request, const DescribeParameterGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Returns the detailed parameter list for a particular parameter
+         * group.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DescribeParameters">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DescribeParametersOutcome DescribeParameters(const Model::DescribeParametersRequest& request) const;
+
+        /**
+         * <p>Returns the detailed parameter list for a particular parameter
+         * group.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DescribeParameters">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DescribeParametersOutcomeCallable DescribeParametersCallable(const Model::DescribeParametersRequest& request) const;
+
+        /**
+         * <p>Returns the detailed parameter list for a particular parameter
+         * group.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DescribeParameters">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DescribeParametersAsync(const Model::DescribeParametersRequest& request, const DescribeParametersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Returns a list of subnet group descriptions. If a subnet group name is
+         * specified, the list will contain only the description of that
+         * group.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DescribeSubnetGroups">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DescribeSubnetGroupsOutcome DescribeSubnetGroups(const Model::DescribeSubnetGroupsRequest& request) const;
+
+        /**
+         * <p>Returns a list of subnet group descriptions. If a subnet group name is
+         * specified, the list will contain only the description of that
+         * group.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DescribeSubnetGroups">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DescribeSubnetGroupsOutcomeCallable DescribeSubnetGroupsCallable(const Model::DescribeSubnetGroupsRequest& request) const;
+
+        /**
+         * <p>Returns a list of subnet group descriptions. If a subnet group name is
+         * specified, the list will contain only the description of that
+         * group.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DescribeSubnetGroups">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DescribeSubnetGroupsAsync(const Model::DescribeSubnetGroupsRequest& request, const DescribeSubnetGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Adds one or more nodes to a DAX cluster.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/IncreaseReplicationFactor">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::IncreaseReplicationFactorOutcome IncreaseReplicationFactor(const Model::IncreaseReplicationFactorRequest& request) const;
+
+        /**
+         * <p>Adds one or more nodes to a DAX cluster.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/IncreaseReplicationFactor">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::IncreaseReplicationFactorOutcomeCallable IncreaseReplicationFactorCallable(const Model::IncreaseReplicationFactorRequest& request) const;
+
+        /**
+         * <p>Adds one or more nodes to a DAX cluster.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/IncreaseReplicationFactor">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void IncreaseReplicationFactorAsync(const Model::IncreaseReplicationFactorRequest& request, const IncreaseReplicationFactorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>List all of the tags for a DAX cluster. You can call <code>ListTags</code> up
+         * to 10 times per second, per account.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/ListTags">AWS API
+         * Reference</a></p>
+         */
+        virtual Model::ListTagsOutcome ListTags(const Model::ListTagsRequest& request) const;
+
+        /**
+         * <p>List all of the tags for a DAX cluster. You can call <code>ListTags</code> up
+         * to 10 times per second, per account.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/ListTags">AWS API
+         * Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::ListTagsOutcomeCallable ListTagsCallable(const Model::ListTagsRequest& request) const;
+
+        /**
+         * <p>List all of the tags for a DAX cluster. You can call <code>ListTags</code> up
+         * to 10 times per second, per account.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/ListTags">AWS API
+         * Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void ListTagsAsync(const Model::ListTagsRequest& request, const ListTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Reboots a single node of a DAX cluster. The reboot action takes place as soon
+         * as possible. During the reboot, the node status is set to REBOOTING.</p> 
+         * <p> <code>RebootNode</code> restarts the DAX engine process and does not remove
+         * the contents of the cache. </p> <p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/RebootNode">AWS API
+         * Reference</a></p>
+         */
+        virtual Model::RebootNodeOutcome RebootNode(const Model::RebootNodeRequest& request) const;
+
+        /**
+         * <p>Reboots a single node of a DAX cluster. The reboot action takes place as soon
+         * as possible. During the reboot, the node status is set to REBOOTING.</p> 
+         * <p> <code>RebootNode</code> restarts the DAX engine process and does not remove
+         * the contents of the cache. </p> <p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/RebootNode">AWS API
+         * Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::RebootNodeOutcomeCallable RebootNodeCallable(const Model::RebootNodeRequest& request) const;
+
+        /**
+         * <p>Reboots a single node of a DAX cluster. The reboot action takes place as soon
+         * as possible. During the reboot, the node status is set to REBOOTING.</p> 
+         * <p> <code>RebootNode</code> restarts the DAX engine process and does not remove
+         * the contents of the cache. </p> <p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/RebootNode">AWS API
+         * Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void RebootNodeAsync(const Model::RebootNodeRequest& request, const RebootNodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Associates a set of tags with a DAX resource. You can call
+         * <code>TagResource</code> up to 5 times per second, per account. </p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/TagResource">AWS API
+         * Reference</a></p>
+         */
+        virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
+
+        /**
+         * <p>Associates a set of tags with a DAX resource. You can call
+         * <code>TagResource</code> up to 5 times per second, per account. </p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/TagResource">AWS API
+         * Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::TagResourceOutcomeCallable TagResourceCallable(const Model::TagResourceRequest& request) const;
+
+        /**
+         * <p>Associates a set of tags with a DAX resource. You can call
+         * <code>TagResource</code> up to 5 times per second, per account. </p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/TagResource">AWS API
+         * Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void TagResourceAsync(const Model::TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Removes the association of tags from a DAX resource. You can call
+         * <code>UntagResource</code> up to 5 times per second, per account. </p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/UntagResource">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
+
+        /**
+         * <p>Removes the association of tags from a DAX resource. You can call
+         * <code>UntagResource</code> up to 5 times per second, per account. </p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/UntagResource">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::UntagResourceOutcomeCallable UntagResourceCallable(const Model::UntagResourceRequest& request) const;
+
+        /**
+         * <p>Removes the association of tags from a DAX resource. You can call
+         * <code>UntagResource</code> up to 5 times per second, per account. </p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/UntagResource">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void UntagResourceAsync(const Model::UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Modifies the settings for a DAX cluster. You can use this action to change
+         * one or more cluster configuration parameters by specifying the parameters and
+         * the new values.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/UpdateCluster">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::UpdateClusterOutcome UpdateCluster(const Model::UpdateClusterRequest& request) const;
+
+        /**
+         * <p>Modifies the settings for a DAX cluster. You can use this action to change
+         * one or more cluster configuration parameters by specifying the parameters and
+         * the new values.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/UpdateCluster">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::UpdateClusterOutcomeCallable UpdateClusterCallable(const Model::UpdateClusterRequest& request) const;
+
+        /**
+         * <p>Modifies the settings for a DAX cluster. You can use this action to change
+         * one or more cluster configuration parameters by specifying the parameters and
+         * the new values.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/UpdateCluster">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void UpdateClusterAsync(const Model::UpdateClusterRequest& request, const UpdateClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Modifies the parameters of a parameter group. You can modify up to 20
+         * parameters in a single request by submitting a list parameter name and value
+         * pairs.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/UpdateParameterGroup">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::UpdateParameterGroupOutcome UpdateParameterGroup(const Model::UpdateParameterGroupRequest& request) const;
+
+        /**
+         * <p>Modifies the parameters of a parameter group. You can modify up to 20
+         * parameters in a single request by submitting a list parameter name and value
+         * pairs.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/UpdateParameterGroup">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::UpdateParameterGroupOutcomeCallable UpdateParameterGroupCallable(const Model::UpdateParameterGroupRequest& request) const;
+
+        /**
+         * <p>Modifies the parameters of a parameter group. You can modify up to 20
+         * parameters in a single request by submitting a list parameter name and value
+         * pairs.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/UpdateParameterGroup">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void UpdateParameterGroupAsync(const Model::UpdateParameterGroupRequest& request, const UpdateParameterGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Modifies an existing subnet group.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/UpdateSubnetGroup">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::UpdateSubnetGroupOutcome UpdateSubnetGroup(const Model::UpdateSubnetGroupRequest& request) const;
+
+        /**
+         * <p>Modifies an existing subnet group.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/UpdateSubnetGroup">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::UpdateSubnetGroupOutcomeCallable UpdateSubnetGroupCallable(const Model::UpdateSubnetGroupRequest& request) const;
+
+        /**
+         * <p>Modifies an existing subnet group.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/UpdateSubnetGroup">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void UpdateSubnetGroupAsync(const Model::UpdateSubnetGroupRequest& request, const UpdateSubnetGroupResponseReceivedHandler& 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 CreateClusterAsyncHelper(const Model::CreateClusterRequest& request, const CreateClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void CreateParameterGroupAsyncHelper(const Model::CreateParameterGroupRequest& request, const CreateParameterGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void CreateSubnetGroupAsyncHelper(const Model::CreateSubnetGroupRequest& request, const CreateSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DecreaseReplicationFactorAsyncHelper(const Model::DecreaseReplicationFactorRequest& request, const DecreaseReplicationFactorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DeleteClusterAsyncHelper(const Model::DeleteClusterRequest& request, const DeleteClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DeleteParameterGroupAsyncHelper(const Model::DeleteParameterGroupRequest& request, const DeleteParameterGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DeleteSubnetGroupAsyncHelper(const Model::DeleteSubnetGroupRequest& request, const DeleteSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DescribeClustersAsyncHelper(const Model::DescribeClustersRequest& request, const DescribeClustersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DescribeDefaultParametersAsyncHelper(const Model::DescribeDefaultParametersRequest& request, const DescribeDefaultParametersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DescribeEventsAsyncHelper(const Model::DescribeEventsRequest& request, const DescribeEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DescribeParameterGroupsAsyncHelper(const Model::DescribeParameterGroupsRequest& request, const DescribeParameterGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DescribeParametersAsyncHelper(const Model::DescribeParametersRequest& request, const DescribeParametersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DescribeSubnetGroupsAsyncHelper(const Model::DescribeSubnetGroupsRequest& request, const DescribeSubnetGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void IncreaseReplicationFactorAsyncHelper(const Model::IncreaseReplicationFactorRequest& request, const IncreaseReplicationFactorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void ListTagsAsyncHelper(const Model::ListTagsRequest& request, const ListTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void RebootNodeAsyncHelper(const Model::RebootNodeRequest& request, const RebootNodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void TagResourceAsyncHelper(const Model::TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void UntagResourceAsyncHelper(const Model::UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void UpdateClusterAsyncHelper(const Model::UpdateClusterRequest& request, const UpdateClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void UpdateParameterGroupAsyncHelper(const Model::UpdateParameterGroupRequest& request, const UpdateParameterGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void UpdateSubnetGroupAsyncHelper(const Model::UpdateSubnetGroupRequest& request, const UpdateSubnetGroupResponseReceivedHandler& 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 DAX
+} // namespace Aws

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

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/DAXErrorMarshaller.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/dax/DAX_EXPORTS.h>
+#include <aws/core/client/AWSErrorMarshaller.h>
+
+namespace Aws
+{
+namespace Client
+{
+
+class AWS_DAX_API DAXErrorMarshaller : public Aws::Client::JsonErrorMarshaller
+{
+public:
+  Aws::Client::AWSError<Aws::Client::CoreErrors> FindErrorByName(const char* exceptionName) const override;
+};
+
+} // namespace Client
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/DAXErrors.h

@@ -0,0 +1,95 @@
+/**
+ * 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/dax/DAX_EXPORTS.h>
+
+namespace Aws
+{
+namespace DAX
+{
+enum class DAXErrors
+{
+  //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,
+  ///////////////////////////////////////////////////////////////////////////////////////////
+
+  CLUSTER_ALREADY_EXISTS_FAULT= static_cast<int>(Aws::Client::CoreErrors::SERVICE_EXTENSION_START_RANGE) + 1,
+  CLUSTER_NOT_FOUND_FAULT,
+  CLUSTER_QUOTA_FOR_CUSTOMER_EXCEEDED_FAULT,
+  INSUFFICIENT_CLUSTER_CAPACITY_FAULT,
+  INVALID_A_R_N_FAULT,
+  INVALID_CLUSTER_STATE_FAULT,
+  INVALID_PARAMETER_GROUP_STATE_FAULT,
+  INVALID_SUBNET,
+  INVALID_V_P_C_NETWORK_STATE_FAULT,
+  NODE_NOT_FOUND_FAULT,
+  NODE_QUOTA_FOR_CLUSTER_EXCEEDED_FAULT,
+  NODE_QUOTA_FOR_CUSTOMER_EXCEEDED_FAULT,
+  PARAMETER_GROUP_ALREADY_EXISTS_FAULT,
+  PARAMETER_GROUP_NOT_FOUND_FAULT,
+  PARAMETER_GROUP_QUOTA_EXCEEDED_FAULT,
+  SERVICE_LINKED_ROLE_NOT_FOUND_FAULT,
+  SUBNET_GROUP_ALREADY_EXISTS_FAULT,
+  SUBNET_GROUP_IN_USE_FAULT,
+  SUBNET_GROUP_NOT_FOUND_FAULT,
+  SUBNET_GROUP_QUOTA_EXCEEDED_FAULT,
+  SUBNET_IN_USE,
+  SUBNET_QUOTA_EXCEEDED_FAULT,
+  TAG_NOT_FOUND_FAULT,
+  TAG_QUOTA_PER_RESOURCE_EXCEEDED
+};
+
+class AWS_DAX_API DAXError : public Aws::Client::AWSError<DAXErrors>
+{
+public:
+  DAXError() {}
+  DAXError(const Aws::Client::AWSError<Aws::Client::CoreErrors>& rhs) : Aws::Client::AWSError<DAXErrors>(rhs) {}
+  DAXError(Aws::Client::AWSError<Aws::Client::CoreErrors>&& rhs) : Aws::Client::AWSError<DAXErrors>(rhs) {}
+  DAXError(const Aws::Client::AWSError<DAXErrors>& rhs) : Aws::Client::AWSError<DAXErrors>(rhs) {}
+  DAXError(Aws::Client::AWSError<DAXErrors>&& rhs) : Aws::Client::AWSError<DAXErrors>(rhs) {}
+
+  template <typename T>
+  T GetModeledError();
+};
+
+namespace DAXErrorMapper
+{
+  AWS_DAX_API Aws::Client::AWSError<Aws::Client::CoreErrors> GetErrorForName(const char* errorName);
+}
+
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/DAXRequest.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/dax/DAX_EXPORTS.h>
+#include <aws/core/AmazonSerializableWebServiceRequest.h>
+#include <aws/core/utils/UnreferencedParam.h>
+#include <aws/core/http/HttpRequest.h>
+
+namespace Aws
+{
+namespace DAX
+{
+  class AWS_DAX_API DAXRequest : public Aws::AmazonSerializableWebServiceRequest
+  {
+  public:
+    virtual ~DAXRequest () {}
+
+    void AddParametersToRequest(Aws::Http::HttpRequest& httpRequest) const { AWS_UNREFERENCED_PARAM(httpRequest); }
+
+    inline Aws::Http::HeaderValueCollection GetHeaders() const override
+    {
+      auto headers = GetRequestSpecificHeaders();
+
+      if(headers.size() == 0 || (headers.size() > 0 && headers.count(Aws::Http::CONTENT_TYPE_HEADER) == 0))
+      {
+        headers.emplace(Aws::Http::HeaderValuePair(Aws::Http::CONTENT_TYPE_HEADER, Aws::AMZN_JSON_CONTENT_TYPE_1_1 ));
+      }
+      headers.emplace(Aws::Http::HeaderValuePair(Aws::Http::API_VERSION_HEADER, "2017-04-19"));
+      return headers;
+    }
+
+  protected:
+    virtual Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const { return Aws::Http::HeaderValueCollection(); }
+
+  };
+
+
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/DAX_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_DAX_EXPORTS
+            #define AWS_DAX_API __declspec(dllexport)
+        #else
+            #define AWS_DAX_API __declspec(dllimport)
+        #endif /* AWS_DAX_EXPORTS */
+    #else
+        #define AWS_DAX_API
+    #endif // USE_IMPORT_EXPORT
+#else // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)
+    #define AWS_DAX_API
+#endif // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/ChangeType.h

@@ -0,0 +1,31 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace DAX
+{
+namespace Model
+{
+  enum class ChangeType
+  {
+    NOT_SET,
+    IMMEDIATE,
+    REQUIRES_REBOOT
+  };
+
+namespace ChangeTypeMapper
+{
+AWS_DAX_API ChangeType GetChangeTypeForName(const Aws::String& name);
+
+AWS_DAX_API Aws::String GetNameForChangeType(ChangeType value);
+} // namespace ChangeTypeMapper
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/Cluster.h

@@ -0,0 +1,821 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/dax/model/Endpoint.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/dax/model/NotificationConfiguration.h>
+#include <aws/dax/model/ParameterGroupStatus.h>
+#include <aws/dax/model/SSEDescription.h>
+#include <aws/dax/model/Node.h>
+#include <aws/dax/model/SecurityGroupMembership.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   * <p>Contains all of the attributes of a specific DAX cluster.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/Cluster">AWS API
+   * Reference</a></p>
+   */
+  class AWS_DAX_API Cluster
+  {
+  public:
+    Cluster();
+    Cluster(Aws::Utils::Json::JsonView jsonValue);
+    Cluster& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The name of the DAX cluster.</p>
+     */
+    inline const Aws::String& GetClusterName() const{ return m_clusterName; }
+
+    /**
+     * <p>The name of the DAX cluster.</p>
+     */
+    inline bool ClusterNameHasBeenSet() const { return m_clusterNameHasBeenSet; }
+
+    /**
+     * <p>The name of the DAX cluster.</p>
+     */
+    inline void SetClusterName(const Aws::String& value) { m_clusterNameHasBeenSet = true; m_clusterName = value; }
+
+    /**
+     * <p>The name of the DAX cluster.</p>
+     */
+    inline void SetClusterName(Aws::String&& value) { m_clusterNameHasBeenSet = true; m_clusterName = std::move(value); }
+
+    /**
+     * <p>The name of the DAX cluster.</p>
+     */
+    inline void SetClusterName(const char* value) { m_clusterNameHasBeenSet = true; m_clusterName.assign(value); }
+
+    /**
+     * <p>The name of the DAX cluster.</p>
+     */
+    inline Cluster& WithClusterName(const Aws::String& value) { SetClusterName(value); return *this;}
+
+    /**
+     * <p>The name of the DAX cluster.</p>
+     */
+    inline Cluster& WithClusterName(Aws::String&& value) { SetClusterName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the DAX cluster.</p>
+     */
+    inline Cluster& WithClusterName(const char* value) { SetClusterName(value); return *this;}
+
+
+    /**
+     * <p>The description of the cluster.</p>
+     */
+    inline const Aws::String& GetDescription() const{ return m_description; }
+
+    /**
+     * <p>The description of the cluster.</p>
+     */
+    inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
+
+    /**
+     * <p>The description of the cluster.</p>
+     */
+    inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
+
+    /**
+     * <p>The description of the cluster.</p>
+     */
+    inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
+
+    /**
+     * <p>The description of the cluster.</p>
+     */
+    inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
+
+    /**
+     * <p>The description of the cluster.</p>
+     */
+    inline Cluster& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
+
+    /**
+     * <p>The description of the cluster.</p>
+     */
+    inline Cluster& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
+
+    /**
+     * <p>The description of the cluster.</p>
+     */
+    inline Cluster& WithDescription(const char* value) { SetDescription(value); return *this;}
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that uniquely identifies the cluster. </p>
+     */
+    inline const Aws::String& GetClusterArn() const{ return m_clusterArn; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that uniquely identifies the cluster. </p>
+     */
+    inline bool ClusterArnHasBeenSet() const { return m_clusterArnHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that uniquely identifies the cluster. </p>
+     */
+    inline void SetClusterArn(const Aws::String& value) { m_clusterArnHasBeenSet = true; m_clusterArn = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that uniquely identifies the cluster. </p>
+     */
+    inline void SetClusterArn(Aws::String&& value) { m_clusterArnHasBeenSet = true; m_clusterArn = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that uniquely identifies the cluster. </p>
+     */
+    inline void SetClusterArn(const char* value) { m_clusterArnHasBeenSet = true; m_clusterArn.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that uniquely identifies the cluster. </p>
+     */
+    inline Cluster& WithClusterArn(const Aws::String& value) { SetClusterArn(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that uniquely identifies the cluster. </p>
+     */
+    inline Cluster& WithClusterArn(Aws::String&& value) { SetClusterArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that uniquely identifies the cluster. </p>
+     */
+    inline Cluster& WithClusterArn(const char* value) { SetClusterArn(value); return *this;}
+
+
+    /**
+     * <p>The total number of nodes in the cluster.</p>
+     */
+    inline int GetTotalNodes() const{ return m_totalNodes; }
+
+    /**
+     * <p>The total number of nodes in the cluster.</p>
+     */
+    inline bool TotalNodesHasBeenSet() const { return m_totalNodesHasBeenSet; }
+
+    /**
+     * <p>The total number of nodes in the cluster.</p>
+     */
+    inline void SetTotalNodes(int value) { m_totalNodesHasBeenSet = true; m_totalNodes = value; }
+
+    /**
+     * <p>The total number of nodes in the cluster.</p>
+     */
+    inline Cluster& WithTotalNodes(int value) { SetTotalNodes(value); return *this;}
+
+
+    /**
+     * <p>The number of nodes in the cluster that are active (i.e., capable of serving
+     * requests).</p>
+     */
+    inline int GetActiveNodes() const{ return m_activeNodes; }
+
+    /**
+     * <p>The number of nodes in the cluster that are active (i.e., capable of serving
+     * requests).</p>
+     */
+    inline bool ActiveNodesHasBeenSet() const { return m_activeNodesHasBeenSet; }
+
+    /**
+     * <p>The number of nodes in the cluster that are active (i.e., capable of serving
+     * requests).</p>
+     */
+    inline void SetActiveNodes(int value) { m_activeNodesHasBeenSet = true; m_activeNodes = value; }
+
+    /**
+     * <p>The number of nodes in the cluster that are active (i.e., capable of serving
+     * requests).</p>
+     */
+    inline Cluster& WithActiveNodes(int value) { SetActiveNodes(value); return *this;}
+
+
+    /**
+     * <p>The node type for the nodes in the cluster. (All nodes in a DAX cluster are
+     * of the same type.)</p>
+     */
+    inline const Aws::String& GetNodeType() const{ return m_nodeType; }
+
+    /**
+     * <p>The node type for the nodes in the cluster. (All nodes in a DAX cluster are
+     * of the same type.)</p>
+     */
+    inline bool NodeTypeHasBeenSet() const { return m_nodeTypeHasBeenSet; }
+
+    /**
+     * <p>The node type for the nodes in the cluster. (All nodes in a DAX cluster are
+     * of the same type.)</p>
+     */
+    inline void SetNodeType(const Aws::String& value) { m_nodeTypeHasBeenSet = true; m_nodeType = value; }
+
+    /**
+     * <p>The node type for the nodes in the cluster. (All nodes in a DAX cluster are
+     * of the same type.)</p>
+     */
+    inline void SetNodeType(Aws::String&& value) { m_nodeTypeHasBeenSet = true; m_nodeType = std::move(value); }
+
+    /**
+     * <p>The node type for the nodes in the cluster. (All nodes in a DAX cluster are
+     * of the same type.)</p>
+     */
+    inline void SetNodeType(const char* value) { m_nodeTypeHasBeenSet = true; m_nodeType.assign(value); }
+
+    /**
+     * <p>The node type for the nodes in the cluster. (All nodes in a DAX cluster are
+     * of the same type.)</p>
+     */
+    inline Cluster& WithNodeType(const Aws::String& value) { SetNodeType(value); return *this;}
+
+    /**
+     * <p>The node type for the nodes in the cluster. (All nodes in a DAX cluster are
+     * of the same type.)</p>
+     */
+    inline Cluster& WithNodeType(Aws::String&& value) { SetNodeType(std::move(value)); return *this;}
+
+    /**
+     * <p>The node type for the nodes in the cluster. (All nodes in a DAX cluster are
+     * of the same type.)</p>
+     */
+    inline Cluster& WithNodeType(const char* value) { SetNodeType(value); return *this;}
+
+
+    /**
+     * <p>The current status of the cluster.</p>
+     */
+    inline const Aws::String& GetStatus() const{ return m_status; }
+
+    /**
+     * <p>The current status of the cluster.</p>
+     */
+    inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
+
+    /**
+     * <p>The current status of the cluster.</p>
+     */
+    inline void SetStatus(const Aws::String& value) { m_statusHasBeenSet = true; m_status = value; }
+
+    /**
+     * <p>The current status of the cluster.</p>
+     */
+    inline void SetStatus(Aws::String&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }
+
+    /**
+     * <p>The current status of the cluster.</p>
+     */
+    inline void SetStatus(const char* value) { m_statusHasBeenSet = true; m_status.assign(value); }
+
+    /**
+     * <p>The current status of the cluster.</p>
+     */
+    inline Cluster& WithStatus(const Aws::String& value) { SetStatus(value); return *this;}
+
+    /**
+     * <p>The current status of the cluster.</p>
+     */
+    inline Cluster& WithStatus(Aws::String&& value) { SetStatus(std::move(value)); return *this;}
+
+    /**
+     * <p>The current status of the cluster.</p>
+     */
+    inline Cluster& WithStatus(const char* value) { SetStatus(value); return *this;}
+
+
+    /**
+     * <p>The configuration endpoint for this DAX cluster, consisting of a DNS name and
+     * a port number. Client applications can specify this endpoint, rather than an
+     * individual node endpoint, and allow the DAX client software to intelligently
+     * route requests and responses to nodes in the DAX cluster.</p>
+     */
+    inline const Endpoint& GetClusterDiscoveryEndpoint() const{ return m_clusterDiscoveryEndpoint; }
+
+    /**
+     * <p>The configuration endpoint for this DAX cluster, consisting of a DNS name and
+     * a port number. Client applications can specify this endpoint, rather than an
+     * individual node endpoint, and allow the DAX client software to intelligently
+     * route requests and responses to nodes in the DAX cluster.</p>
+     */
+    inline bool ClusterDiscoveryEndpointHasBeenSet() const { return m_clusterDiscoveryEndpointHasBeenSet; }
+
+    /**
+     * <p>The configuration endpoint for this DAX cluster, consisting of a DNS name and
+     * a port number. Client applications can specify this endpoint, rather than an
+     * individual node endpoint, and allow the DAX client software to intelligently
+     * route requests and responses to nodes in the DAX cluster.</p>
+     */
+    inline void SetClusterDiscoveryEndpoint(const Endpoint& value) { m_clusterDiscoveryEndpointHasBeenSet = true; m_clusterDiscoveryEndpoint = value; }
+
+    /**
+     * <p>The configuration endpoint for this DAX cluster, consisting of a DNS name and
+     * a port number. Client applications can specify this endpoint, rather than an
+     * individual node endpoint, and allow the DAX client software to intelligently
+     * route requests and responses to nodes in the DAX cluster.</p>
+     */
+    inline void SetClusterDiscoveryEndpoint(Endpoint&& value) { m_clusterDiscoveryEndpointHasBeenSet = true; m_clusterDiscoveryEndpoint = std::move(value); }
+
+    /**
+     * <p>The configuration endpoint for this DAX cluster, consisting of a DNS name and
+     * a port number. Client applications can specify this endpoint, rather than an
+     * individual node endpoint, and allow the DAX client software to intelligently
+     * route requests and responses to nodes in the DAX cluster.</p>
+     */
+    inline Cluster& WithClusterDiscoveryEndpoint(const Endpoint& value) { SetClusterDiscoveryEndpoint(value); return *this;}
+
+    /**
+     * <p>The configuration endpoint for this DAX cluster, consisting of a DNS name and
+     * a port number. Client applications can specify this endpoint, rather than an
+     * individual node endpoint, and allow the DAX client software to intelligently
+     * route requests and responses to nodes in the DAX cluster.</p>
+     */
+    inline Cluster& WithClusterDiscoveryEndpoint(Endpoint&& value) { SetClusterDiscoveryEndpoint(std::move(value)); return *this;}
+
+
+    /**
+     * <p>A list of nodes to be removed from the cluster.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetNodeIdsToRemove() const{ return m_nodeIdsToRemove; }
+
+    /**
+     * <p>A list of nodes to be removed from the cluster.</p>
+     */
+    inline bool NodeIdsToRemoveHasBeenSet() const { return m_nodeIdsToRemoveHasBeenSet; }
+
+    /**
+     * <p>A list of nodes to be removed from the cluster.</p>
+     */
+    inline void SetNodeIdsToRemove(const Aws::Vector<Aws::String>& value) { m_nodeIdsToRemoveHasBeenSet = true; m_nodeIdsToRemove = value; }
+
+    /**
+     * <p>A list of nodes to be removed from the cluster.</p>
+     */
+    inline void SetNodeIdsToRemove(Aws::Vector<Aws::String>&& value) { m_nodeIdsToRemoveHasBeenSet = true; m_nodeIdsToRemove = std::move(value); }
+
+    /**
+     * <p>A list of nodes to be removed from the cluster.</p>
+     */
+    inline Cluster& WithNodeIdsToRemove(const Aws::Vector<Aws::String>& value) { SetNodeIdsToRemove(value); return *this;}
+
+    /**
+     * <p>A list of nodes to be removed from the cluster.</p>
+     */
+    inline Cluster& WithNodeIdsToRemove(Aws::Vector<Aws::String>&& value) { SetNodeIdsToRemove(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of nodes to be removed from the cluster.</p>
+     */
+    inline Cluster& AddNodeIdsToRemove(const Aws::String& value) { m_nodeIdsToRemoveHasBeenSet = true; m_nodeIdsToRemove.push_back(value); return *this; }
+
+    /**
+     * <p>A list of nodes to be removed from the cluster.</p>
+     */
+    inline Cluster& AddNodeIdsToRemove(Aws::String&& value) { m_nodeIdsToRemoveHasBeenSet = true; m_nodeIdsToRemove.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>A list of nodes to be removed from the cluster.</p>
+     */
+    inline Cluster& AddNodeIdsToRemove(const char* value) { m_nodeIdsToRemoveHasBeenSet = true; m_nodeIdsToRemove.push_back(value); return *this; }
+
+
+    /**
+     * <p>A list of nodes that are currently in the cluster.</p>
+     */
+    inline const Aws::Vector<Node>& GetNodes() const{ return m_nodes; }
+
+    /**
+     * <p>A list of nodes that are currently in the cluster.</p>
+     */
+    inline bool NodesHasBeenSet() const { return m_nodesHasBeenSet; }
+
+    /**
+     * <p>A list of nodes that are currently in the cluster.</p>
+     */
+    inline void SetNodes(const Aws::Vector<Node>& value) { m_nodesHasBeenSet = true; m_nodes = value; }
+
+    /**
+     * <p>A list of nodes that are currently in the cluster.</p>
+     */
+    inline void SetNodes(Aws::Vector<Node>&& value) { m_nodesHasBeenSet = true; m_nodes = std::move(value); }
+
+    /**
+     * <p>A list of nodes that are currently in the cluster.</p>
+     */
+    inline Cluster& WithNodes(const Aws::Vector<Node>& value) { SetNodes(value); return *this;}
+
+    /**
+     * <p>A list of nodes that are currently in the cluster.</p>
+     */
+    inline Cluster& WithNodes(Aws::Vector<Node>&& value) { SetNodes(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of nodes that are currently in the cluster.</p>
+     */
+    inline Cluster& AddNodes(const Node& value) { m_nodesHasBeenSet = true; m_nodes.push_back(value); return *this; }
+
+    /**
+     * <p>A list of nodes that are currently in the cluster.</p>
+     */
+    inline Cluster& AddNodes(Node&& value) { m_nodesHasBeenSet = true; m_nodes.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>A range of time when maintenance of DAX cluster software will be performed.
+     * For example: <code>sun:01:00-sun:09:00</code>. Cluster maintenance normally
+     * takes less than 30 minutes, and is performed automatically within the
+     * maintenance window.</p>
+     */
+    inline const Aws::String& GetPreferredMaintenanceWindow() const{ return m_preferredMaintenanceWindow; }
+
+    /**
+     * <p>A range of time when maintenance of DAX cluster software will be performed.
+     * For example: <code>sun:01:00-sun:09:00</code>. Cluster maintenance normally
+     * takes less than 30 minutes, and is performed automatically within the
+     * maintenance window.</p>
+     */
+    inline bool PreferredMaintenanceWindowHasBeenSet() const { return m_preferredMaintenanceWindowHasBeenSet; }
+
+    /**
+     * <p>A range of time when maintenance of DAX cluster software will be performed.
+     * For example: <code>sun:01:00-sun:09:00</code>. Cluster maintenance normally
+     * takes less than 30 minutes, and is performed automatically within the
+     * maintenance window.</p>
+     */
+    inline void SetPreferredMaintenanceWindow(const Aws::String& value) { m_preferredMaintenanceWindowHasBeenSet = true; m_preferredMaintenanceWindow = value; }
+
+    /**
+     * <p>A range of time when maintenance of DAX cluster software will be performed.
+     * For example: <code>sun:01:00-sun:09:00</code>. Cluster maintenance normally
+     * takes less than 30 minutes, and is performed automatically within the
+     * maintenance window.</p>
+     */
+    inline void SetPreferredMaintenanceWindow(Aws::String&& value) { m_preferredMaintenanceWindowHasBeenSet = true; m_preferredMaintenanceWindow = std::move(value); }
+
+    /**
+     * <p>A range of time when maintenance of DAX cluster software will be performed.
+     * For example: <code>sun:01:00-sun:09:00</code>. Cluster maintenance normally
+     * takes less than 30 minutes, and is performed automatically within the
+     * maintenance window.</p>
+     */
+    inline void SetPreferredMaintenanceWindow(const char* value) { m_preferredMaintenanceWindowHasBeenSet = true; m_preferredMaintenanceWindow.assign(value); }
+
+    /**
+     * <p>A range of time when maintenance of DAX cluster software will be performed.
+     * For example: <code>sun:01:00-sun:09:00</code>. Cluster maintenance normally
+     * takes less than 30 minutes, and is performed automatically within the
+     * maintenance window.</p>
+     */
+    inline Cluster& WithPreferredMaintenanceWindow(const Aws::String& value) { SetPreferredMaintenanceWindow(value); return *this;}
+
+    /**
+     * <p>A range of time when maintenance of DAX cluster software will be performed.
+     * For example: <code>sun:01:00-sun:09:00</code>. Cluster maintenance normally
+     * takes less than 30 minutes, and is performed automatically within the
+     * maintenance window.</p>
+     */
+    inline Cluster& WithPreferredMaintenanceWindow(Aws::String&& value) { SetPreferredMaintenanceWindow(std::move(value)); return *this;}
+
+    /**
+     * <p>A range of time when maintenance of DAX cluster software will be performed.
+     * For example: <code>sun:01:00-sun:09:00</code>. Cluster maintenance normally
+     * takes less than 30 minutes, and is performed automatically within the
+     * maintenance window.</p>
+     */
+    inline Cluster& WithPreferredMaintenanceWindow(const char* value) { SetPreferredMaintenanceWindow(value); return *this;}
+
+
+    /**
+     * <p>Describes a notification topic and its status. Notification topics are used
+     * for publishing DAX events to subscribers using Amazon Simple Notification
+     * Service (SNS).</p>
+     */
+    inline const NotificationConfiguration& GetNotificationConfiguration() const{ return m_notificationConfiguration; }
+
+    /**
+     * <p>Describes a notification topic and its status. Notification topics are used
+     * for publishing DAX events to subscribers using Amazon Simple Notification
+     * Service (SNS).</p>
+     */
+    inline bool NotificationConfigurationHasBeenSet() const { return m_notificationConfigurationHasBeenSet; }
+
+    /**
+     * <p>Describes a notification topic and its status. Notification topics are used
+     * for publishing DAX events to subscribers using Amazon Simple Notification
+     * Service (SNS).</p>
+     */
+    inline void SetNotificationConfiguration(const NotificationConfiguration& value) { m_notificationConfigurationHasBeenSet = true; m_notificationConfiguration = value; }
+
+    /**
+     * <p>Describes a notification topic and its status. Notification topics are used
+     * for publishing DAX events to subscribers using Amazon Simple Notification
+     * Service (SNS).</p>
+     */
+    inline void SetNotificationConfiguration(NotificationConfiguration&& value) { m_notificationConfigurationHasBeenSet = true; m_notificationConfiguration = std::move(value); }
+
+    /**
+     * <p>Describes a notification topic and its status. Notification topics are used
+     * for publishing DAX events to subscribers using Amazon Simple Notification
+     * Service (SNS).</p>
+     */
+    inline Cluster& WithNotificationConfiguration(const NotificationConfiguration& value) { SetNotificationConfiguration(value); return *this;}
+
+    /**
+     * <p>Describes a notification topic and its status. Notification topics are used
+     * for publishing DAX events to subscribers using Amazon Simple Notification
+     * Service (SNS).</p>
+     */
+    inline Cluster& WithNotificationConfiguration(NotificationConfiguration&& value) { SetNotificationConfiguration(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The subnet group where the DAX cluster is running.</p>
+     */
+    inline const Aws::String& GetSubnetGroup() const{ return m_subnetGroup; }
+
+    /**
+     * <p>The subnet group where the DAX cluster is running.</p>
+     */
+    inline bool SubnetGroupHasBeenSet() const { return m_subnetGroupHasBeenSet; }
+
+    /**
+     * <p>The subnet group where the DAX cluster is running.</p>
+     */
+    inline void SetSubnetGroup(const Aws::String& value) { m_subnetGroupHasBeenSet = true; m_subnetGroup = value; }
+
+    /**
+     * <p>The subnet group where the DAX cluster is running.</p>
+     */
+    inline void SetSubnetGroup(Aws::String&& value) { m_subnetGroupHasBeenSet = true; m_subnetGroup = std::move(value); }
+
+    /**
+     * <p>The subnet group where the DAX cluster is running.</p>
+     */
+    inline void SetSubnetGroup(const char* value) { m_subnetGroupHasBeenSet = true; m_subnetGroup.assign(value); }
+
+    /**
+     * <p>The subnet group where the DAX cluster is running.</p>
+     */
+    inline Cluster& WithSubnetGroup(const Aws::String& value) { SetSubnetGroup(value); return *this;}
+
+    /**
+     * <p>The subnet group where the DAX cluster is running.</p>
+     */
+    inline Cluster& WithSubnetGroup(Aws::String&& value) { SetSubnetGroup(std::move(value)); return *this;}
+
+    /**
+     * <p>The subnet group where the DAX cluster is running.</p>
+     */
+    inline Cluster& WithSubnetGroup(const char* value) { SetSubnetGroup(value); return *this;}
+
+
+    /**
+     * <p>A list of security groups, and the status of each, for the nodes in the
+     * cluster.</p>
+     */
+    inline const Aws::Vector<SecurityGroupMembership>& GetSecurityGroups() const{ return m_securityGroups; }
+
+    /**
+     * <p>A list of security groups, and the status of each, for the nodes in the
+     * cluster.</p>
+     */
+    inline bool SecurityGroupsHasBeenSet() const { return m_securityGroupsHasBeenSet; }
+
+    /**
+     * <p>A list of security groups, and the status of each, for the nodes in the
+     * cluster.</p>
+     */
+    inline void SetSecurityGroups(const Aws::Vector<SecurityGroupMembership>& value) { m_securityGroupsHasBeenSet = true; m_securityGroups = value; }
+
+    /**
+     * <p>A list of security groups, and the status of each, for the nodes in the
+     * cluster.</p>
+     */
+    inline void SetSecurityGroups(Aws::Vector<SecurityGroupMembership>&& value) { m_securityGroupsHasBeenSet = true; m_securityGroups = std::move(value); }
+
+    /**
+     * <p>A list of security groups, and the status of each, for the nodes in the
+     * cluster.</p>
+     */
+    inline Cluster& WithSecurityGroups(const Aws::Vector<SecurityGroupMembership>& value) { SetSecurityGroups(value); return *this;}
+
+    /**
+     * <p>A list of security groups, and the status of each, for the nodes in the
+     * cluster.</p>
+     */
+    inline Cluster& WithSecurityGroups(Aws::Vector<SecurityGroupMembership>&& value) { SetSecurityGroups(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of security groups, and the status of each, for the nodes in the
+     * cluster.</p>
+     */
+    inline Cluster& AddSecurityGroups(const SecurityGroupMembership& value) { m_securityGroupsHasBeenSet = true; m_securityGroups.push_back(value); return *this; }
+
+    /**
+     * <p>A list of security groups, and the status of each, for the nodes in the
+     * cluster.</p>
+     */
+    inline Cluster& AddSecurityGroups(SecurityGroupMembership&& value) { m_securityGroupsHasBeenSet = true; m_securityGroups.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>A valid Amazon Resource Name (ARN) that identifies an IAM role. At runtime,
+     * DAX will assume this role and use the role's permissions to access DynamoDB on
+     * your behalf.</p>
+     */
+    inline const Aws::String& GetIamRoleArn() const{ return m_iamRoleArn; }
+
+    /**
+     * <p>A valid Amazon Resource Name (ARN) that identifies an IAM role. At runtime,
+     * DAX will assume this role and use the role's permissions to access DynamoDB on
+     * your behalf.</p>
+     */
+    inline bool IamRoleArnHasBeenSet() const { return m_iamRoleArnHasBeenSet; }
+
+    /**
+     * <p>A valid Amazon Resource Name (ARN) that identifies an IAM role. At runtime,
+     * DAX will assume this role and use the role's permissions to access DynamoDB on
+     * your behalf.</p>
+     */
+    inline void SetIamRoleArn(const Aws::String& value) { m_iamRoleArnHasBeenSet = true; m_iamRoleArn = value; }
+
+    /**
+     * <p>A valid Amazon Resource Name (ARN) that identifies an IAM role. At runtime,
+     * DAX will assume this role and use the role's permissions to access DynamoDB on
+     * your behalf.</p>
+     */
+    inline void SetIamRoleArn(Aws::String&& value) { m_iamRoleArnHasBeenSet = true; m_iamRoleArn = std::move(value); }
+
+    /**
+     * <p>A valid Amazon Resource Name (ARN) that identifies an IAM role. At runtime,
+     * DAX will assume this role and use the role's permissions to access DynamoDB on
+     * your behalf.</p>
+     */
+    inline void SetIamRoleArn(const char* value) { m_iamRoleArnHasBeenSet = true; m_iamRoleArn.assign(value); }
+
+    /**
+     * <p>A valid Amazon Resource Name (ARN) that identifies an IAM role. At runtime,
+     * DAX will assume this role and use the role's permissions to access DynamoDB on
+     * your behalf.</p>
+     */
+    inline Cluster& WithIamRoleArn(const Aws::String& value) { SetIamRoleArn(value); return *this;}
+
+    /**
+     * <p>A valid Amazon Resource Name (ARN) that identifies an IAM role. At runtime,
+     * DAX will assume this role and use the role's permissions to access DynamoDB on
+     * your behalf.</p>
+     */
+    inline Cluster& WithIamRoleArn(Aws::String&& value) { SetIamRoleArn(std::move(value)); return *this;}
+
+    /**
+     * <p>A valid Amazon Resource Name (ARN) that identifies an IAM role. At runtime,
+     * DAX will assume this role and use the role's permissions to access DynamoDB on
+     * your behalf.</p>
+     */
+    inline Cluster& WithIamRoleArn(const char* value) { SetIamRoleArn(value); return *this;}
+
+
+    /**
+     * <p>The parameter group being used by nodes in the cluster.</p>
+     */
+    inline const ParameterGroupStatus& GetParameterGroup() const{ return m_parameterGroup; }
+
+    /**
+     * <p>The parameter group being used by nodes in the cluster.</p>
+     */
+    inline bool ParameterGroupHasBeenSet() const { return m_parameterGroupHasBeenSet; }
+
+    /**
+     * <p>The parameter group being used by nodes in the cluster.</p>
+     */
+    inline void SetParameterGroup(const ParameterGroupStatus& value) { m_parameterGroupHasBeenSet = true; m_parameterGroup = value; }
+
+    /**
+     * <p>The parameter group being used by nodes in the cluster.</p>
+     */
+    inline void SetParameterGroup(ParameterGroupStatus&& value) { m_parameterGroupHasBeenSet = true; m_parameterGroup = std::move(value); }
+
+    /**
+     * <p>The parameter group being used by nodes in the cluster.</p>
+     */
+    inline Cluster& WithParameterGroup(const ParameterGroupStatus& value) { SetParameterGroup(value); return *this;}
+
+    /**
+     * <p>The parameter group being used by nodes in the cluster.</p>
+     */
+    inline Cluster& WithParameterGroup(ParameterGroupStatus&& value) { SetParameterGroup(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The description of the server-side encryption status on the specified DAX
+     * cluster.</p>
+     */
+    inline const SSEDescription& GetSSEDescription() const{ return m_sSEDescription; }
+
+    /**
+     * <p>The description of the server-side encryption status on the specified DAX
+     * cluster.</p>
+     */
+    inline bool SSEDescriptionHasBeenSet() const { return m_sSEDescriptionHasBeenSet; }
+
+    /**
+     * <p>The description of the server-side encryption status on the specified DAX
+     * cluster.</p>
+     */
+    inline void SetSSEDescription(const SSEDescription& value) { m_sSEDescriptionHasBeenSet = true; m_sSEDescription = value; }
+
+    /**
+     * <p>The description of the server-side encryption status on the specified DAX
+     * cluster.</p>
+     */
+    inline void SetSSEDescription(SSEDescription&& value) { m_sSEDescriptionHasBeenSet = true; m_sSEDescription = std::move(value); }
+
+    /**
+     * <p>The description of the server-side encryption status on the specified DAX
+     * cluster.</p>
+     */
+    inline Cluster& WithSSEDescription(const SSEDescription& value) { SetSSEDescription(value); return *this;}
+
+    /**
+     * <p>The description of the server-side encryption status on the specified DAX
+     * cluster.</p>
+     */
+    inline Cluster& WithSSEDescription(SSEDescription&& value) { SetSSEDescription(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_clusterName;
+    bool m_clusterNameHasBeenSet;
+
+    Aws::String m_description;
+    bool m_descriptionHasBeenSet;
+
+    Aws::String m_clusterArn;
+    bool m_clusterArnHasBeenSet;
+
+    int m_totalNodes;
+    bool m_totalNodesHasBeenSet;
+
+    int m_activeNodes;
+    bool m_activeNodesHasBeenSet;
+
+    Aws::String m_nodeType;
+    bool m_nodeTypeHasBeenSet;
+
+    Aws::String m_status;
+    bool m_statusHasBeenSet;
+
+    Endpoint m_clusterDiscoveryEndpoint;
+    bool m_clusterDiscoveryEndpointHasBeenSet;
+
+    Aws::Vector<Aws::String> m_nodeIdsToRemove;
+    bool m_nodeIdsToRemoveHasBeenSet;
+
+    Aws::Vector<Node> m_nodes;
+    bool m_nodesHasBeenSet;
+
+    Aws::String m_preferredMaintenanceWindow;
+    bool m_preferredMaintenanceWindowHasBeenSet;
+
+    NotificationConfiguration m_notificationConfiguration;
+    bool m_notificationConfigurationHasBeenSet;
+
+    Aws::String m_subnetGroup;
+    bool m_subnetGroupHasBeenSet;
+
+    Aws::Vector<SecurityGroupMembership> m_securityGroups;
+    bool m_securityGroupsHasBeenSet;
+
+    Aws::String m_iamRoleArn;
+    bool m_iamRoleArnHasBeenSet;
+
+    ParameterGroupStatus m_parameterGroup;
+    bool m_parameterGroupHasBeenSet;
+
+    SSEDescription m_sSEDescription;
+    bool m_sSEDescriptionHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/CreateClusterRequest.h

@@ -0,0 +1,852 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/DAXRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/dax/model/SSESpecification.h>
+#include <aws/dax/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DAX_API CreateClusterRequest : public DAXRequest
+  {
+  public:
+    CreateClusterRequest();
+
+    // 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 "CreateCluster"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The cluster identifier. This parameter is stored as a lowercase string.</p>
+     * <p> <b>Constraints:</b> </p> <ul> <li> <p>A name must contain from 1 to 20
+     * alphanumeric characters or hyphens.</p> </li> <li> <p>The first character must
+     * be a letter.</p> </li> <li> <p>A name cannot end with a hyphen or contain two
+     * consecutive hyphens.</p> </li> </ul>
+     */
+    inline const Aws::String& GetClusterName() const{ return m_clusterName; }
+
+    /**
+     * <p>The cluster identifier. This parameter is stored as a lowercase string.</p>
+     * <p> <b>Constraints:</b> </p> <ul> <li> <p>A name must contain from 1 to 20
+     * alphanumeric characters or hyphens.</p> </li> <li> <p>The first character must
+     * be a letter.</p> </li> <li> <p>A name cannot end with a hyphen or contain two
+     * consecutive hyphens.</p> </li> </ul>
+     */
+    inline bool ClusterNameHasBeenSet() const { return m_clusterNameHasBeenSet; }
+
+    /**
+     * <p>The cluster identifier. This parameter is stored as a lowercase string.</p>
+     * <p> <b>Constraints:</b> </p> <ul> <li> <p>A name must contain from 1 to 20
+     * alphanumeric characters or hyphens.</p> </li> <li> <p>The first character must
+     * be a letter.</p> </li> <li> <p>A name cannot end with a hyphen or contain two
+     * consecutive hyphens.</p> </li> </ul>
+     */
+    inline void SetClusterName(const Aws::String& value) { m_clusterNameHasBeenSet = true; m_clusterName = value; }
+
+    /**
+     * <p>The cluster identifier. This parameter is stored as a lowercase string.</p>
+     * <p> <b>Constraints:</b> </p> <ul> <li> <p>A name must contain from 1 to 20
+     * alphanumeric characters or hyphens.</p> </li> <li> <p>The first character must
+     * be a letter.</p> </li> <li> <p>A name cannot end with a hyphen or contain two
+     * consecutive hyphens.</p> </li> </ul>
+     */
+    inline void SetClusterName(Aws::String&& value) { m_clusterNameHasBeenSet = true; m_clusterName = std::move(value); }
+
+    /**
+     * <p>The cluster identifier. This parameter is stored as a lowercase string.</p>
+     * <p> <b>Constraints:</b> </p> <ul> <li> <p>A name must contain from 1 to 20
+     * alphanumeric characters or hyphens.</p> </li> <li> <p>The first character must
+     * be a letter.</p> </li> <li> <p>A name cannot end with a hyphen or contain two
+     * consecutive hyphens.</p> </li> </ul>
+     */
+    inline void SetClusterName(const char* value) { m_clusterNameHasBeenSet = true; m_clusterName.assign(value); }
+
+    /**
+     * <p>The cluster identifier. This parameter is stored as a lowercase string.</p>
+     * <p> <b>Constraints:</b> </p> <ul> <li> <p>A name must contain from 1 to 20
+     * alphanumeric characters or hyphens.</p> </li> <li> <p>The first character must
+     * be a letter.</p> </li> <li> <p>A name cannot end with a hyphen or contain two
+     * consecutive hyphens.</p> </li> </ul>
+     */
+    inline CreateClusterRequest& WithClusterName(const Aws::String& value) { SetClusterName(value); return *this;}
+
+    /**
+     * <p>The cluster identifier. This parameter is stored as a lowercase string.</p>
+     * <p> <b>Constraints:</b> </p> <ul> <li> <p>A name must contain from 1 to 20
+     * alphanumeric characters or hyphens.</p> </li> <li> <p>The first character must
+     * be a letter.</p> </li> <li> <p>A name cannot end with a hyphen or contain two
+     * consecutive hyphens.</p> </li> </ul>
+     */
+    inline CreateClusterRequest& WithClusterName(Aws::String&& value) { SetClusterName(std::move(value)); return *this;}
+
+    /**
+     * <p>The cluster identifier. This parameter is stored as a lowercase string.</p>
+     * <p> <b>Constraints:</b> </p> <ul> <li> <p>A name must contain from 1 to 20
+     * alphanumeric characters or hyphens.</p> </li> <li> <p>The first character must
+     * be a letter.</p> </li> <li> <p>A name cannot end with a hyphen or contain two
+     * consecutive hyphens.</p> </li> </ul>
+     */
+    inline CreateClusterRequest& WithClusterName(const char* value) { SetClusterName(value); return *this;}
+
+
+    /**
+     * <p>The compute and memory capacity of the nodes in the cluster.</p>
+     */
+    inline const Aws::String& GetNodeType() const{ return m_nodeType; }
+
+    /**
+     * <p>The compute and memory capacity of the nodes in the cluster.</p>
+     */
+    inline bool NodeTypeHasBeenSet() const { return m_nodeTypeHasBeenSet; }
+
+    /**
+     * <p>The compute and memory capacity of the nodes in the cluster.</p>
+     */
+    inline void SetNodeType(const Aws::String& value) { m_nodeTypeHasBeenSet = true; m_nodeType = value; }
+
+    /**
+     * <p>The compute and memory capacity of the nodes in the cluster.</p>
+     */
+    inline void SetNodeType(Aws::String&& value) { m_nodeTypeHasBeenSet = true; m_nodeType = std::move(value); }
+
+    /**
+     * <p>The compute and memory capacity of the nodes in the cluster.</p>
+     */
+    inline void SetNodeType(const char* value) { m_nodeTypeHasBeenSet = true; m_nodeType.assign(value); }
+
+    /**
+     * <p>The compute and memory capacity of the nodes in the cluster.</p>
+     */
+    inline CreateClusterRequest& WithNodeType(const Aws::String& value) { SetNodeType(value); return *this;}
+
+    /**
+     * <p>The compute and memory capacity of the nodes in the cluster.</p>
+     */
+    inline CreateClusterRequest& WithNodeType(Aws::String&& value) { SetNodeType(std::move(value)); return *this;}
+
+    /**
+     * <p>The compute and memory capacity of the nodes in the cluster.</p>
+     */
+    inline CreateClusterRequest& WithNodeType(const char* value) { SetNodeType(value); return *this;}
+
+
+    /**
+     * <p>A description of the cluster.</p>
+     */
+    inline const Aws::String& GetDescription() const{ return m_description; }
+
+    /**
+     * <p>A description of the cluster.</p>
+     */
+    inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
+
+    /**
+     * <p>A description of the cluster.</p>
+     */
+    inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
+
+    /**
+     * <p>A description of the cluster.</p>
+     */
+    inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
+
+    /**
+     * <p>A description of the cluster.</p>
+     */
+    inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
+
+    /**
+     * <p>A description of the cluster.</p>
+     */
+    inline CreateClusterRequest& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
+
+    /**
+     * <p>A description of the cluster.</p>
+     */
+    inline CreateClusterRequest& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
+
+    /**
+     * <p>A description of the cluster.</p>
+     */
+    inline CreateClusterRequest& WithDescription(const char* value) { SetDescription(value); return *this;}
+
+
+    /**
+     * <p>The number of nodes in the DAX cluster. A replication factor of 1 will create
+     * a single-node cluster, without any read replicas. For additional fault
+     * tolerance, you can create a multiple node cluster with one or more read
+     * replicas. To do this, set <code>ReplicationFactor</code> to a number between 3
+     * (one primary and two read replicas) and 10 (one primary and nine read replicas).
+     * <code>If the AvailabilityZones</code> parameter is provided, its length must
+     * equal the <code>ReplicationFactor</code>.</p>  <p>AWS recommends that you
+     * have at least two read replicas per cluster.</p> 
+     */
+    inline int GetReplicationFactor() const{ return m_replicationFactor; }
+
+    /**
+     * <p>The number of nodes in the DAX cluster. A replication factor of 1 will create
+     * a single-node cluster, without any read replicas. For additional fault
+     * tolerance, you can create a multiple node cluster with one or more read
+     * replicas. To do this, set <code>ReplicationFactor</code> to a number between 3
+     * (one primary and two read replicas) and 10 (one primary and nine read replicas).
+     * <code>If the AvailabilityZones</code> parameter is provided, its length must
+     * equal the <code>ReplicationFactor</code>.</p>  <p>AWS recommends that you
+     * have at least two read replicas per cluster.</p> 
+     */
+    inline bool ReplicationFactorHasBeenSet() const { return m_replicationFactorHasBeenSet; }
+
+    /**
+     * <p>The number of nodes in the DAX cluster. A replication factor of 1 will create
+     * a single-node cluster, without any read replicas. For additional fault
+     * tolerance, you can create a multiple node cluster with one or more read
+     * replicas. To do this, set <code>ReplicationFactor</code> to a number between 3
+     * (one primary and two read replicas) and 10 (one primary and nine read replicas).
+     * <code>If the AvailabilityZones</code> parameter is provided, its length must
+     * equal the <code>ReplicationFactor</code>.</p>  <p>AWS recommends that you
+     * have at least two read replicas per cluster.</p> 
+     */
+    inline void SetReplicationFactor(int value) { m_replicationFactorHasBeenSet = true; m_replicationFactor = value; }
+
+    /**
+     * <p>The number of nodes in the DAX cluster. A replication factor of 1 will create
+     * a single-node cluster, without any read replicas. For additional fault
+     * tolerance, you can create a multiple node cluster with one or more read
+     * replicas. To do this, set <code>ReplicationFactor</code> to a number between 3
+     * (one primary and two read replicas) and 10 (one primary and nine read replicas).
+     * <code>If the AvailabilityZones</code> parameter is provided, its length must
+     * equal the <code>ReplicationFactor</code>.</p>  <p>AWS recommends that you
+     * have at least two read replicas per cluster.</p> 
+     */
+    inline CreateClusterRequest& WithReplicationFactor(int value) { SetReplicationFactor(value); return *this;}
+
+
+    /**
+     * <p>The Availability Zones (AZs) in which the cluster nodes will reside after the
+     * cluster has been created or updated. If provided, the length of this list must
+     * equal the <code>ReplicationFactor</code> parameter. If you omit this parameter,
+     * DAX will spread the nodes across Availability Zones for the highest
+     * availability.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetAvailabilityZones() const{ return m_availabilityZones; }
+
+    /**
+     * <p>The Availability Zones (AZs) in which the cluster nodes will reside after the
+     * cluster has been created or updated. If provided, the length of this list must
+     * equal the <code>ReplicationFactor</code> parameter. If you omit this parameter,
+     * DAX will spread the nodes across Availability Zones for the highest
+     * availability.</p>
+     */
+    inline bool AvailabilityZonesHasBeenSet() const { return m_availabilityZonesHasBeenSet; }
+
+    /**
+     * <p>The Availability Zones (AZs) in which the cluster nodes will reside after the
+     * cluster has been created or updated. If provided, the length of this list must
+     * equal the <code>ReplicationFactor</code> parameter. If you omit this parameter,
+     * DAX will spread the nodes across Availability Zones for the highest
+     * availability.</p>
+     */
+    inline void SetAvailabilityZones(const Aws::Vector<Aws::String>& value) { m_availabilityZonesHasBeenSet = true; m_availabilityZones = value; }
+
+    /**
+     * <p>The Availability Zones (AZs) in which the cluster nodes will reside after the
+     * cluster has been created or updated. If provided, the length of this list must
+     * equal the <code>ReplicationFactor</code> parameter. If you omit this parameter,
+     * DAX will spread the nodes across Availability Zones for the highest
+     * availability.</p>
+     */
+    inline void SetAvailabilityZones(Aws::Vector<Aws::String>&& value) { m_availabilityZonesHasBeenSet = true; m_availabilityZones = std::move(value); }
+
+    /**
+     * <p>The Availability Zones (AZs) in which the cluster nodes will reside after the
+     * cluster has been created or updated. If provided, the length of this list must
+     * equal the <code>ReplicationFactor</code> parameter. If you omit this parameter,
+     * DAX will spread the nodes across Availability Zones for the highest
+     * availability.</p>
+     */
+    inline CreateClusterRequest& WithAvailabilityZones(const Aws::Vector<Aws::String>& value) { SetAvailabilityZones(value); return *this;}
+
+    /**
+     * <p>The Availability Zones (AZs) in which the cluster nodes will reside after the
+     * cluster has been created or updated. If provided, the length of this list must
+     * equal the <code>ReplicationFactor</code> parameter. If you omit this parameter,
+     * DAX will spread the nodes across Availability Zones for the highest
+     * availability.</p>
+     */
+    inline CreateClusterRequest& WithAvailabilityZones(Aws::Vector<Aws::String>&& value) { SetAvailabilityZones(std::move(value)); return *this;}
+
+    /**
+     * <p>The Availability Zones (AZs) in which the cluster nodes will reside after the
+     * cluster has been created or updated. If provided, the length of this list must
+     * equal the <code>ReplicationFactor</code> parameter. If you omit this parameter,
+     * DAX will spread the nodes across Availability Zones for the highest
+     * availability.</p>
+     */
+    inline CreateClusterRequest& AddAvailabilityZones(const Aws::String& value) { m_availabilityZonesHasBeenSet = true; m_availabilityZones.push_back(value); return *this; }
+
+    /**
+     * <p>The Availability Zones (AZs) in which the cluster nodes will reside after the
+     * cluster has been created or updated. If provided, the length of this list must
+     * equal the <code>ReplicationFactor</code> parameter. If you omit this parameter,
+     * DAX will spread the nodes across Availability Zones for the highest
+     * availability.</p>
+     */
+    inline CreateClusterRequest& AddAvailabilityZones(Aws::String&& value) { m_availabilityZonesHasBeenSet = true; m_availabilityZones.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>The Availability Zones (AZs) in which the cluster nodes will reside after the
+     * cluster has been created or updated. If provided, the length of this list must
+     * equal the <code>ReplicationFactor</code> parameter. If you omit this parameter,
+     * DAX will spread the nodes across Availability Zones for the highest
+     * availability.</p>
+     */
+    inline CreateClusterRequest& AddAvailabilityZones(const char* value) { m_availabilityZonesHasBeenSet = true; m_availabilityZones.push_back(value); return *this; }
+
+
+    /**
+     * <p>The name of the subnet group to be used for the replication group.</p>
+     *  <p>DAX clusters can only run in an Amazon VPC environment. All of
+     * the subnets that you specify in a subnet group must exist in the same VPC.</p>
+     * 
+     */
+    inline const Aws::String& GetSubnetGroupName() const{ return m_subnetGroupName; }
+
+    /**
+     * <p>The name of the subnet group to be used for the replication group.</p>
+     *  <p>DAX clusters can only run in an Amazon VPC environment. All of
+     * the subnets that you specify in a subnet group must exist in the same VPC.</p>
+     * 
+     */
+    inline bool SubnetGroupNameHasBeenSet() const { return m_subnetGroupNameHasBeenSet; }
+
+    /**
+     * <p>The name of the subnet group to be used for the replication group.</p>
+     *  <p>DAX clusters can only run in an Amazon VPC environment. All of
+     * the subnets that you specify in a subnet group must exist in the same VPC.</p>
+     * 
+     */
+    inline void SetSubnetGroupName(const Aws::String& value) { m_subnetGroupNameHasBeenSet = true; m_subnetGroupName = value; }
+
+    /**
+     * <p>The name of the subnet group to be used for the replication group.</p>
+     *  <p>DAX clusters can only run in an Amazon VPC environment. All of
+     * the subnets that you specify in a subnet group must exist in the same VPC.</p>
+     * 
+     */
+    inline void SetSubnetGroupName(Aws::String&& value) { m_subnetGroupNameHasBeenSet = true; m_subnetGroupName = std::move(value); }
+
+    /**
+     * <p>The name of the subnet group to be used for the replication group.</p>
+     *  <p>DAX clusters can only run in an Amazon VPC environment. All of
+     * the subnets that you specify in a subnet group must exist in the same VPC.</p>
+     * 
+     */
+    inline void SetSubnetGroupName(const char* value) { m_subnetGroupNameHasBeenSet = true; m_subnetGroupName.assign(value); }
+
+    /**
+     * <p>The name of the subnet group to be used for the replication group.</p>
+     *  <p>DAX clusters can only run in an Amazon VPC environment. All of
+     * the subnets that you specify in a subnet group must exist in the same VPC.</p>
+     * 
+     */
+    inline CreateClusterRequest& WithSubnetGroupName(const Aws::String& value) { SetSubnetGroupName(value); return *this;}
+
+    /**
+     * <p>The name of the subnet group to be used for the replication group.</p>
+     *  <p>DAX clusters can only run in an Amazon VPC environment. All of
+     * the subnets that you specify in a subnet group must exist in the same VPC.</p>
+     * 
+     */
+    inline CreateClusterRequest& WithSubnetGroupName(Aws::String&& value) { SetSubnetGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the subnet group to be used for the replication group.</p>
+     *  <p>DAX clusters can only run in an Amazon VPC environment. All of
+     * the subnets that you specify in a subnet group must exist in the same VPC.</p>
+     * 
+     */
+    inline CreateClusterRequest& WithSubnetGroupName(const char* value) { SetSubnetGroupName(value); return *this;}
+
+
+    /**
+     * <p>A list of security group IDs to be assigned to each node in the DAX cluster.
+     * (Each of the security group ID is system-generated.)</p> <p>If this parameter is
+     * not specified, DAX assigns the default VPC security group to each node.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetSecurityGroupIds() const{ return m_securityGroupIds; }
+
+    /**
+     * <p>A list of security group IDs to be assigned to each node in the DAX cluster.
+     * (Each of the security group ID is system-generated.)</p> <p>If this parameter is
+     * not specified, DAX assigns the default VPC security group to each node.</p>
+     */
+    inline bool SecurityGroupIdsHasBeenSet() const { return m_securityGroupIdsHasBeenSet; }
+
+    /**
+     * <p>A list of security group IDs to be assigned to each node in the DAX cluster.
+     * (Each of the security group ID is system-generated.)</p> <p>If this parameter is
+     * not specified, DAX assigns the default VPC security group to each node.</p>
+     */
+    inline void SetSecurityGroupIds(const Aws::Vector<Aws::String>& value) { m_securityGroupIdsHasBeenSet = true; m_securityGroupIds = value; }
+
+    /**
+     * <p>A list of security group IDs to be assigned to each node in the DAX cluster.
+     * (Each of the security group ID is system-generated.)</p> <p>If this parameter is
+     * not specified, DAX assigns the default VPC security group to each node.</p>
+     */
+    inline void SetSecurityGroupIds(Aws::Vector<Aws::String>&& value) { m_securityGroupIdsHasBeenSet = true; m_securityGroupIds = std::move(value); }
+
+    /**
+     * <p>A list of security group IDs to be assigned to each node in the DAX cluster.
+     * (Each of the security group ID is system-generated.)</p> <p>If this parameter is
+     * not specified, DAX assigns the default VPC security group to each node.</p>
+     */
+    inline CreateClusterRequest& WithSecurityGroupIds(const Aws::Vector<Aws::String>& value) { SetSecurityGroupIds(value); return *this;}
+
+    /**
+     * <p>A list of security group IDs to be assigned to each node in the DAX cluster.
+     * (Each of the security group ID is system-generated.)</p> <p>If this parameter is
+     * not specified, DAX assigns the default VPC security group to each node.</p>
+     */
+    inline CreateClusterRequest& WithSecurityGroupIds(Aws::Vector<Aws::String>&& value) { SetSecurityGroupIds(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of security group IDs to be assigned to each node in the DAX cluster.
+     * (Each of the security group ID is system-generated.)</p> <p>If this parameter is
+     * not specified, DAX assigns the default VPC security group to each node.</p>
+     */
+    inline CreateClusterRequest& AddSecurityGroupIds(const Aws::String& value) { m_securityGroupIdsHasBeenSet = true; m_securityGroupIds.push_back(value); return *this; }
+
+    /**
+     * <p>A list of security group IDs to be assigned to each node in the DAX cluster.
+     * (Each of the security group ID is system-generated.)</p> <p>If this parameter is
+     * not specified, DAX assigns the default VPC security group to each node.</p>
+     */
+    inline CreateClusterRequest& AddSecurityGroupIds(Aws::String&& value) { m_securityGroupIdsHasBeenSet = true; m_securityGroupIds.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>A list of security group IDs to be assigned to each node in the DAX cluster.
+     * (Each of the security group ID is system-generated.)</p> <p>If this parameter is
+     * not specified, DAX assigns the default VPC security group to each node.</p>
+     */
+    inline CreateClusterRequest& AddSecurityGroupIds(const char* value) { m_securityGroupIdsHasBeenSet = true; m_securityGroupIds.push_back(value); return *this; }
+
+
+    /**
+     * <p>Specifies the weekly time range during which maintenance on the DAX cluster
+     * is performed. It is specified as a range in the format ddd:hh24:mi-ddd:hh24:mi
+     * (24H Clock UTC). The minimum maintenance window is a 60 minute period. Valid
+     * values for <code>ddd</code> are:</p> <ul> <li> <p> <code>sun</code> </p> </li>
+     * <li> <p> <code>mon</code> </p> </li> <li> <p> <code>tue</code> </p> </li> <li>
+     * <p> <code>wed</code> </p> </li> <li> <p> <code>thu</code> </p> </li> <li> <p>
+     * <code>fri</code> </p> </li> <li> <p> <code>sat</code> </p> </li> </ul>
+     * <p>Example: <code>sun:05:00-sun:09:00</code> </p>  <p>If you don't specify
+     * a preferred maintenance window when you create or modify a cache cluster, DAX
+     * assigns a 60-minute maintenance window on a randomly selected day of the
+     * week.</p> 
+     */
+    inline const Aws::String& GetPreferredMaintenanceWindow() const{ return m_preferredMaintenanceWindow; }
+
+    /**
+     * <p>Specifies the weekly time range during which maintenance on the DAX cluster
+     * is performed. It is specified as a range in the format ddd:hh24:mi-ddd:hh24:mi
+     * (24H Clock UTC). The minimum maintenance window is a 60 minute period. Valid
+     * values for <code>ddd</code> are:</p> <ul> <li> <p> <code>sun</code> </p> </li>
+     * <li> <p> <code>mon</code> </p> </li> <li> <p> <code>tue</code> </p> </li> <li>
+     * <p> <code>wed</code> </p> </li> <li> <p> <code>thu</code> </p> </li> <li> <p>
+     * <code>fri</code> </p> </li> <li> <p> <code>sat</code> </p> </li> </ul>
+     * <p>Example: <code>sun:05:00-sun:09:00</code> </p>  <p>If you don't specify
+     * a preferred maintenance window when you create or modify a cache cluster, DAX
+     * assigns a 60-minute maintenance window on a randomly selected day of the
+     * week.</p> 
+     */
+    inline bool PreferredMaintenanceWindowHasBeenSet() const { return m_preferredMaintenanceWindowHasBeenSet; }
+
+    /**
+     * <p>Specifies the weekly time range during which maintenance on the DAX cluster
+     * is performed. It is specified as a range in the format ddd:hh24:mi-ddd:hh24:mi
+     * (24H Clock UTC). The minimum maintenance window is a 60 minute period. Valid
+     * values for <code>ddd</code> are:</p> <ul> <li> <p> <code>sun</code> </p> </li>
+     * <li> <p> <code>mon</code> </p> </li> <li> <p> <code>tue</code> </p> </li> <li>
+     * <p> <code>wed</code> </p> </li> <li> <p> <code>thu</code> </p> </li> <li> <p>
+     * <code>fri</code> </p> </li> <li> <p> <code>sat</code> </p> </li> </ul>
+     * <p>Example: <code>sun:05:00-sun:09:00</code> </p>  <p>If you don't specify
+     * a preferred maintenance window when you create or modify a cache cluster, DAX
+     * assigns a 60-minute maintenance window on a randomly selected day of the
+     * week.</p> 
+     */
+    inline void SetPreferredMaintenanceWindow(const Aws::String& value) { m_preferredMaintenanceWindowHasBeenSet = true; m_preferredMaintenanceWindow = value; }
+
+    /**
+     * <p>Specifies the weekly time range during which maintenance on the DAX cluster
+     * is performed. It is specified as a range in the format ddd:hh24:mi-ddd:hh24:mi
+     * (24H Clock UTC). The minimum maintenance window is a 60 minute period. Valid
+     * values for <code>ddd</code> are:</p> <ul> <li> <p> <code>sun</code> </p> </li>
+     * <li> <p> <code>mon</code> </p> </li> <li> <p> <code>tue</code> </p> </li> <li>
+     * <p> <code>wed</code> </p> </li> <li> <p> <code>thu</code> </p> </li> <li> <p>
+     * <code>fri</code> </p> </li> <li> <p> <code>sat</code> </p> </li> </ul>
+     * <p>Example: <code>sun:05:00-sun:09:00</code> </p>  <p>If you don't specify
+     * a preferred maintenance window when you create or modify a cache cluster, DAX
+     * assigns a 60-minute maintenance window on a randomly selected day of the
+     * week.</p> 
+     */
+    inline void SetPreferredMaintenanceWindow(Aws::String&& value) { m_preferredMaintenanceWindowHasBeenSet = true; m_preferredMaintenanceWindow = std::move(value); }
+
+    /**
+     * <p>Specifies the weekly time range during which maintenance on the DAX cluster
+     * is performed. It is specified as a range in the format ddd:hh24:mi-ddd:hh24:mi
+     * (24H Clock UTC). The minimum maintenance window is a 60 minute period. Valid
+     * values for <code>ddd</code> are:</p> <ul> <li> <p> <code>sun</code> </p> </li>
+     * <li> <p> <code>mon</code> </p> </li> <li> <p> <code>tue</code> </p> </li> <li>
+     * <p> <code>wed</code> </p> </li> <li> <p> <code>thu</code> </p> </li> <li> <p>
+     * <code>fri</code> </p> </li> <li> <p> <code>sat</code> </p> </li> </ul>
+     * <p>Example: <code>sun:05:00-sun:09:00</code> </p>  <p>If you don't specify
+     * a preferred maintenance window when you create or modify a cache cluster, DAX
+     * assigns a 60-minute maintenance window on a randomly selected day of the
+     * week.</p> 
+     */
+    inline void SetPreferredMaintenanceWindow(const char* value) { m_preferredMaintenanceWindowHasBeenSet = true; m_preferredMaintenanceWindow.assign(value); }
+
+    /**
+     * <p>Specifies the weekly time range during which maintenance on the DAX cluster
+     * is performed. It is specified as a range in the format ddd:hh24:mi-ddd:hh24:mi
+     * (24H Clock UTC). The minimum maintenance window is a 60 minute period. Valid
+     * values for <code>ddd</code> are:</p> <ul> <li> <p> <code>sun</code> </p> </li>
+     * <li> <p> <code>mon</code> </p> </li> <li> <p> <code>tue</code> </p> </li> <li>
+     * <p> <code>wed</code> </p> </li> <li> <p> <code>thu</code> </p> </li> <li> <p>
+     * <code>fri</code> </p> </li> <li> <p> <code>sat</code> </p> </li> </ul>
+     * <p>Example: <code>sun:05:00-sun:09:00</code> </p>  <p>If you don't specify
+     * a preferred maintenance window when you create or modify a cache cluster, DAX
+     * assigns a 60-minute maintenance window on a randomly selected day of the
+     * week.</p> 
+     */
+    inline CreateClusterRequest& WithPreferredMaintenanceWindow(const Aws::String& value) { SetPreferredMaintenanceWindow(value); return *this;}
+
+    /**
+     * <p>Specifies the weekly time range during which maintenance on the DAX cluster
+     * is performed. It is specified as a range in the format ddd:hh24:mi-ddd:hh24:mi
+     * (24H Clock UTC). The minimum maintenance window is a 60 minute period. Valid
+     * values for <code>ddd</code> are:</p> <ul> <li> <p> <code>sun</code> </p> </li>
+     * <li> <p> <code>mon</code> </p> </li> <li> <p> <code>tue</code> </p> </li> <li>
+     * <p> <code>wed</code> </p> </li> <li> <p> <code>thu</code> </p> </li> <li> <p>
+     * <code>fri</code> </p> </li> <li> <p> <code>sat</code> </p> </li> </ul>
+     * <p>Example: <code>sun:05:00-sun:09:00</code> </p>  <p>If you don't specify
+     * a preferred maintenance window when you create or modify a cache cluster, DAX
+     * assigns a 60-minute maintenance window on a randomly selected day of the
+     * week.</p> 
+     */
+    inline CreateClusterRequest& WithPreferredMaintenanceWindow(Aws::String&& value) { SetPreferredMaintenanceWindow(std::move(value)); return *this;}
+
+    /**
+     * <p>Specifies the weekly time range during which maintenance on the DAX cluster
+     * is performed. It is specified as a range in the format ddd:hh24:mi-ddd:hh24:mi
+     * (24H Clock UTC). The minimum maintenance window is a 60 minute period. Valid
+     * values for <code>ddd</code> are:</p> <ul> <li> <p> <code>sun</code> </p> </li>
+     * <li> <p> <code>mon</code> </p> </li> <li> <p> <code>tue</code> </p> </li> <li>
+     * <p> <code>wed</code> </p> </li> <li> <p> <code>thu</code> </p> </li> <li> <p>
+     * <code>fri</code> </p> </li> <li> <p> <code>sat</code> </p> </li> </ul>
+     * <p>Example: <code>sun:05:00-sun:09:00</code> </p>  <p>If you don't specify
+     * a preferred maintenance window when you create or modify a cache cluster, DAX
+     * assigns a 60-minute maintenance window on a randomly selected day of the
+     * week.</p> 
+     */
+    inline CreateClusterRequest& WithPreferredMaintenanceWindow(const char* value) { SetPreferredMaintenanceWindow(value); return *this;}
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the Amazon SNS topic to which notifications
+     * will be sent.</p>  <p>The Amazon SNS topic owner must be same as the DAX
+     * cluster owner.</p> 
+     */
+    inline const Aws::String& GetNotificationTopicArn() const{ return m_notificationTopicArn; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the Amazon SNS topic to which notifications
+     * will be sent.</p>  <p>The Amazon SNS topic owner must be same as the DAX
+     * cluster owner.</p> 
+     */
+    inline bool NotificationTopicArnHasBeenSet() const { return m_notificationTopicArnHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the Amazon SNS topic to which notifications
+     * will be sent.</p>  <p>The Amazon SNS topic owner must be same as the DAX
+     * cluster owner.</p> 
+     */
+    inline void SetNotificationTopicArn(const Aws::String& value) { m_notificationTopicArnHasBeenSet = true; m_notificationTopicArn = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the Amazon SNS topic to which notifications
+     * will be sent.</p>  <p>The Amazon SNS topic owner must be same as the DAX
+     * cluster owner.</p> 
+     */
+    inline void SetNotificationTopicArn(Aws::String&& value) { m_notificationTopicArnHasBeenSet = true; m_notificationTopicArn = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the Amazon SNS topic to which notifications
+     * will be sent.</p>  <p>The Amazon SNS topic owner must be same as the DAX
+     * cluster owner.</p> 
+     */
+    inline void SetNotificationTopicArn(const char* value) { m_notificationTopicArnHasBeenSet = true; m_notificationTopicArn.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the Amazon SNS topic to which notifications
+     * will be sent.</p>  <p>The Amazon SNS topic owner must be same as the DAX
+     * cluster owner.</p> 
+     */
+    inline CreateClusterRequest& WithNotificationTopicArn(const Aws::String& value) { SetNotificationTopicArn(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the Amazon SNS topic to which notifications
+     * will be sent.</p>  <p>The Amazon SNS topic owner must be same as the DAX
+     * cluster owner.</p> 
+     */
+    inline CreateClusterRequest& WithNotificationTopicArn(Aws::String&& value) { SetNotificationTopicArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the Amazon SNS topic to which notifications
+     * will be sent.</p>  <p>The Amazon SNS topic owner must be same as the DAX
+     * cluster owner.</p> 
+     */
+    inline CreateClusterRequest& WithNotificationTopicArn(const char* value) { SetNotificationTopicArn(value); return *this;}
+
+
+    /**
+     * <p>A valid Amazon Resource Name (ARN) that identifies an IAM role. At runtime,
+     * DAX will assume this role and use the role's permissions to access DynamoDB on
+     * your behalf.</p>
+     */
+    inline const Aws::String& GetIamRoleArn() const{ return m_iamRoleArn; }
+
+    /**
+     * <p>A valid Amazon Resource Name (ARN) that identifies an IAM role. At runtime,
+     * DAX will assume this role and use the role's permissions to access DynamoDB on
+     * your behalf.</p>
+     */
+    inline bool IamRoleArnHasBeenSet() const { return m_iamRoleArnHasBeenSet; }
+
+    /**
+     * <p>A valid Amazon Resource Name (ARN) that identifies an IAM role. At runtime,
+     * DAX will assume this role and use the role's permissions to access DynamoDB on
+     * your behalf.</p>
+     */
+    inline void SetIamRoleArn(const Aws::String& value) { m_iamRoleArnHasBeenSet = true; m_iamRoleArn = value; }
+
+    /**
+     * <p>A valid Amazon Resource Name (ARN) that identifies an IAM role. At runtime,
+     * DAX will assume this role and use the role's permissions to access DynamoDB on
+     * your behalf.</p>
+     */
+    inline void SetIamRoleArn(Aws::String&& value) { m_iamRoleArnHasBeenSet = true; m_iamRoleArn = std::move(value); }
+
+    /**
+     * <p>A valid Amazon Resource Name (ARN) that identifies an IAM role. At runtime,
+     * DAX will assume this role and use the role's permissions to access DynamoDB on
+     * your behalf.</p>
+     */
+    inline void SetIamRoleArn(const char* value) { m_iamRoleArnHasBeenSet = true; m_iamRoleArn.assign(value); }
+
+    /**
+     * <p>A valid Amazon Resource Name (ARN) that identifies an IAM role. At runtime,
+     * DAX will assume this role and use the role's permissions to access DynamoDB on
+     * your behalf.</p>
+     */
+    inline CreateClusterRequest& WithIamRoleArn(const Aws::String& value) { SetIamRoleArn(value); return *this;}
+
+    /**
+     * <p>A valid Amazon Resource Name (ARN) that identifies an IAM role. At runtime,
+     * DAX will assume this role and use the role's permissions to access DynamoDB on
+     * your behalf.</p>
+     */
+    inline CreateClusterRequest& WithIamRoleArn(Aws::String&& value) { SetIamRoleArn(std::move(value)); return *this;}
+
+    /**
+     * <p>A valid Amazon Resource Name (ARN) that identifies an IAM role. At runtime,
+     * DAX will assume this role and use the role's permissions to access DynamoDB on
+     * your behalf.</p>
+     */
+    inline CreateClusterRequest& WithIamRoleArn(const char* value) { SetIamRoleArn(value); return *this;}
+
+
+    /**
+     * <p>The parameter group to be associated with the DAX cluster.</p>
+     */
+    inline const Aws::String& GetParameterGroupName() const{ return m_parameterGroupName; }
+
+    /**
+     * <p>The parameter group to be associated with the DAX cluster.</p>
+     */
+    inline bool ParameterGroupNameHasBeenSet() const { return m_parameterGroupNameHasBeenSet; }
+
+    /**
+     * <p>The parameter group to be associated with the DAX cluster.</p>
+     */
+    inline void SetParameterGroupName(const Aws::String& value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName = value; }
+
+    /**
+     * <p>The parameter group to be associated with the DAX cluster.</p>
+     */
+    inline void SetParameterGroupName(Aws::String&& value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName = std::move(value); }
+
+    /**
+     * <p>The parameter group to be associated with the DAX cluster.</p>
+     */
+    inline void SetParameterGroupName(const char* value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName.assign(value); }
+
+    /**
+     * <p>The parameter group to be associated with the DAX cluster.</p>
+     */
+    inline CreateClusterRequest& WithParameterGroupName(const Aws::String& value) { SetParameterGroupName(value); return *this;}
+
+    /**
+     * <p>The parameter group to be associated with the DAX cluster.</p>
+     */
+    inline CreateClusterRequest& WithParameterGroupName(Aws::String&& value) { SetParameterGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The parameter group to be associated with the DAX cluster.</p>
+     */
+    inline CreateClusterRequest& WithParameterGroupName(const char* value) { SetParameterGroupName(value); return *this;}
+
+
+    /**
+     * <p>A set of tags to associate with the DAX cluster. </p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>A set of tags to associate with the DAX cluster. </p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>A set of tags to associate with the DAX cluster. </p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>A set of tags to associate with the DAX cluster. </p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>A set of tags to associate with the DAX cluster. </p>
+     */
+    inline CreateClusterRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>A set of tags to associate with the DAX cluster. </p>
+     */
+    inline CreateClusterRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>A set of tags to associate with the DAX cluster. </p>
+     */
+    inline CreateClusterRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>A set of tags to associate with the DAX cluster. </p>
+     */
+    inline CreateClusterRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>Represents the settings used to enable server-side encryption on the
+     * cluster.</p>
+     */
+    inline const SSESpecification& GetSSESpecification() const{ return m_sSESpecification; }
+
+    /**
+     * <p>Represents the settings used to enable server-side encryption on the
+     * cluster.</p>
+     */
+    inline bool SSESpecificationHasBeenSet() const { return m_sSESpecificationHasBeenSet; }
+
+    /**
+     * <p>Represents the settings used to enable server-side encryption on the
+     * cluster.</p>
+     */
+    inline void SetSSESpecification(const SSESpecification& value) { m_sSESpecificationHasBeenSet = true; m_sSESpecification = value; }
+
+    /**
+     * <p>Represents the settings used to enable server-side encryption on the
+     * cluster.</p>
+     */
+    inline void SetSSESpecification(SSESpecification&& value) { m_sSESpecificationHasBeenSet = true; m_sSESpecification = std::move(value); }
+
+    /**
+     * <p>Represents the settings used to enable server-side encryption on the
+     * cluster.</p>
+     */
+    inline CreateClusterRequest& WithSSESpecification(const SSESpecification& value) { SetSSESpecification(value); return *this;}
+
+    /**
+     * <p>Represents the settings used to enable server-side encryption on the
+     * cluster.</p>
+     */
+    inline CreateClusterRequest& WithSSESpecification(SSESpecification&& value) { SetSSESpecification(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_clusterName;
+    bool m_clusterNameHasBeenSet;
+
+    Aws::String m_nodeType;
+    bool m_nodeTypeHasBeenSet;
+
+    Aws::String m_description;
+    bool m_descriptionHasBeenSet;
+
+    int m_replicationFactor;
+    bool m_replicationFactorHasBeenSet;
+
+    Aws::Vector<Aws::String> m_availabilityZones;
+    bool m_availabilityZonesHasBeenSet;
+
+    Aws::String m_subnetGroupName;
+    bool m_subnetGroupNameHasBeenSet;
+
+    Aws::Vector<Aws::String> m_securityGroupIds;
+    bool m_securityGroupIdsHasBeenSet;
+
+    Aws::String m_preferredMaintenanceWindow;
+    bool m_preferredMaintenanceWindowHasBeenSet;
+
+    Aws::String m_notificationTopicArn;
+    bool m_notificationTopicArnHasBeenSet;
+
+    Aws::String m_iamRoleArn;
+    bool m_iamRoleArnHasBeenSet;
+
+    Aws::String m_parameterGroupName;
+    bool m_parameterGroupNameHasBeenSet;
+
+    Aws::Vector<Tag> m_tags;
+    bool m_tagsHasBeenSet;
+
+    SSESpecification m_sSESpecification;
+    bool m_sSESpecificationHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/CreateClusterResult.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/model/Cluster.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+  class AWS_DAX_API CreateClusterResult
+  {
+  public:
+    CreateClusterResult();
+    CreateClusterResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    CreateClusterResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>A description of the DAX cluster that you have created.</p>
+     */
+    inline const Cluster& GetCluster() const{ return m_cluster; }
+
+    /**
+     * <p>A description of the DAX cluster that you have created.</p>
+     */
+    inline void SetCluster(const Cluster& value) { m_cluster = value; }
+
+    /**
+     * <p>A description of the DAX cluster that you have created.</p>
+     */
+    inline void SetCluster(Cluster&& value) { m_cluster = std::move(value); }
+
+    /**
+     * <p>A description of the DAX cluster that you have created.</p>
+     */
+    inline CreateClusterResult& WithCluster(const Cluster& value) { SetCluster(value); return *this;}
+
+    /**
+     * <p>A description of the DAX cluster that you have created.</p>
+     */
+    inline CreateClusterResult& WithCluster(Cluster&& value) { SetCluster(std::move(value)); return *this;}
+
+  private:
+
+    Cluster m_cluster;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/CreateParameterGroupRequest.h

@@ -0,0 +1,137 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/DAXRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DAX_API CreateParameterGroupRequest : public DAXRequest
+  {
+  public:
+    CreateParameterGroupRequest();
+
+    // 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 "CreateParameterGroup"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the parameter group to apply to all of the clusters in this
+     * replication group.</p>
+     */
+    inline const Aws::String& GetParameterGroupName() const{ return m_parameterGroupName; }
+
+    /**
+     * <p>The name of the parameter group to apply to all of the clusters in this
+     * replication group.</p>
+     */
+    inline bool ParameterGroupNameHasBeenSet() const { return m_parameterGroupNameHasBeenSet; }
+
+    /**
+     * <p>The name of the parameter group to apply to all of the clusters in this
+     * replication group.</p>
+     */
+    inline void SetParameterGroupName(const Aws::String& value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName = value; }
+
+    /**
+     * <p>The name of the parameter group to apply to all of the clusters in this
+     * replication group.</p>
+     */
+    inline void SetParameterGroupName(Aws::String&& value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName = std::move(value); }
+
+    /**
+     * <p>The name of the parameter group to apply to all of the clusters in this
+     * replication group.</p>
+     */
+    inline void SetParameterGroupName(const char* value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName.assign(value); }
+
+    /**
+     * <p>The name of the parameter group to apply to all of the clusters in this
+     * replication group.</p>
+     */
+    inline CreateParameterGroupRequest& WithParameterGroupName(const Aws::String& value) { SetParameterGroupName(value); return *this;}
+
+    /**
+     * <p>The name of the parameter group to apply to all of the clusters in this
+     * replication group.</p>
+     */
+    inline CreateParameterGroupRequest& WithParameterGroupName(Aws::String&& value) { SetParameterGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the parameter group to apply to all of the clusters in this
+     * replication group.</p>
+     */
+    inline CreateParameterGroupRequest& WithParameterGroupName(const char* value) { SetParameterGroupName(value); return *this;}
+
+
+    /**
+     * <p>A description of the parameter group.</p>
+     */
+    inline const Aws::String& GetDescription() const{ return m_description; }
+
+    /**
+     * <p>A description of the parameter group.</p>
+     */
+    inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
+
+    /**
+     * <p>A description of the parameter group.</p>
+     */
+    inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
+
+    /**
+     * <p>A description of the parameter group.</p>
+     */
+    inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
+
+    /**
+     * <p>A description of the parameter group.</p>
+     */
+    inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
+
+    /**
+     * <p>A description of the parameter group.</p>
+     */
+    inline CreateParameterGroupRequest& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
+
+    /**
+     * <p>A description of the parameter group.</p>
+     */
+    inline CreateParameterGroupRequest& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
+
+    /**
+     * <p>A description of the parameter group.</p>
+     */
+    inline CreateParameterGroupRequest& WithDescription(const char* value) { SetDescription(value); return *this;}
+
+  private:
+
+    Aws::String m_parameterGroupName;
+    bool m_parameterGroupNameHasBeenSet;
+
+    Aws::String m_description;
+    bool m_descriptionHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/CreateParameterGroupResult.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/model/ParameterGroup.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+  class AWS_DAX_API CreateParameterGroupResult
+  {
+  public:
+    CreateParameterGroupResult();
+    CreateParameterGroupResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    CreateParameterGroupResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Represents the output of a <i>CreateParameterGroup</i> action.</p>
+     */
+    inline const ParameterGroup& GetParameterGroup() const{ return m_parameterGroup; }
+
+    /**
+     * <p>Represents the output of a <i>CreateParameterGroup</i> action.</p>
+     */
+    inline void SetParameterGroup(const ParameterGroup& value) { m_parameterGroup = value; }
+
+    /**
+     * <p>Represents the output of a <i>CreateParameterGroup</i> action.</p>
+     */
+    inline void SetParameterGroup(ParameterGroup&& value) { m_parameterGroup = std::move(value); }
+
+    /**
+     * <p>Represents the output of a <i>CreateParameterGroup</i> action.</p>
+     */
+    inline CreateParameterGroupResult& WithParameterGroup(const ParameterGroup& value) { SetParameterGroup(value); return *this;}
+
+    /**
+     * <p>Represents the output of a <i>CreateParameterGroup</i> action.</p>
+     */
+    inline CreateParameterGroupResult& WithParameterGroup(ParameterGroup&& value) { SetParameterGroup(std::move(value)); return *this;}
+
+  private:
+
+    ParameterGroup m_parameterGroup;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/CreateSubnetGroupRequest.h

@@ -0,0 +1,179 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/DAXRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DAX_API CreateSubnetGroupRequest : public DAXRequest
+  {
+  public:
+    CreateSubnetGroupRequest();
+
+    // 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 "CreateSubnetGroup"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>A name for the subnet group. This value is stored as a lowercase string. </p>
+     */
+    inline const Aws::String& GetSubnetGroupName() const{ return m_subnetGroupName; }
+
+    /**
+     * <p>A name for the subnet group. This value is stored as a lowercase string. </p>
+     */
+    inline bool SubnetGroupNameHasBeenSet() const { return m_subnetGroupNameHasBeenSet; }
+
+    /**
+     * <p>A name for the subnet group. This value is stored as a lowercase string. </p>
+     */
+    inline void SetSubnetGroupName(const Aws::String& value) { m_subnetGroupNameHasBeenSet = true; m_subnetGroupName = value; }
+
+    /**
+     * <p>A name for the subnet group. This value is stored as a lowercase string. </p>
+     */
+    inline void SetSubnetGroupName(Aws::String&& value) { m_subnetGroupNameHasBeenSet = true; m_subnetGroupName = std::move(value); }
+
+    /**
+     * <p>A name for the subnet group. This value is stored as a lowercase string. </p>
+     */
+    inline void SetSubnetGroupName(const char* value) { m_subnetGroupNameHasBeenSet = true; m_subnetGroupName.assign(value); }
+
+    /**
+     * <p>A name for the subnet group. This value is stored as a lowercase string. </p>
+     */
+    inline CreateSubnetGroupRequest& WithSubnetGroupName(const Aws::String& value) { SetSubnetGroupName(value); return *this;}
+
+    /**
+     * <p>A name for the subnet group. This value is stored as a lowercase string. </p>
+     */
+    inline CreateSubnetGroupRequest& WithSubnetGroupName(Aws::String&& value) { SetSubnetGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>A name for the subnet group. This value is stored as a lowercase string. </p>
+     */
+    inline CreateSubnetGroupRequest& WithSubnetGroupName(const char* value) { SetSubnetGroupName(value); return *this;}
+
+
+    /**
+     * <p>A description for the subnet group</p>
+     */
+    inline const Aws::String& GetDescription() const{ return m_description; }
+
+    /**
+     * <p>A description for the subnet group</p>
+     */
+    inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
+
+    /**
+     * <p>A description for the subnet group</p>
+     */
+    inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
+
+    /**
+     * <p>A description for the subnet group</p>
+     */
+    inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
+
+    /**
+     * <p>A description for the subnet group</p>
+     */
+    inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
+
+    /**
+     * <p>A description for the subnet group</p>
+     */
+    inline CreateSubnetGroupRequest& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
+
+    /**
+     * <p>A description for the subnet group</p>
+     */
+    inline CreateSubnetGroupRequest& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
+
+    /**
+     * <p>A description for the subnet group</p>
+     */
+    inline CreateSubnetGroupRequest& WithDescription(const char* value) { SetDescription(value); return *this;}
+
+
+    /**
+     * <p>A list of VPC subnet IDs for the subnet group.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetSubnetIds() const{ return m_subnetIds; }
+
+    /**
+     * <p>A list of VPC subnet IDs for the subnet group.</p>
+     */
+    inline bool SubnetIdsHasBeenSet() const { return m_subnetIdsHasBeenSet; }
+
+    /**
+     * <p>A list of VPC subnet IDs for the subnet group.</p>
+     */
+    inline void SetSubnetIds(const Aws::Vector<Aws::String>& value) { m_subnetIdsHasBeenSet = true; m_subnetIds = value; }
+
+    /**
+     * <p>A list of VPC subnet IDs for the subnet group.</p>
+     */
+    inline void SetSubnetIds(Aws::Vector<Aws::String>&& value) { m_subnetIdsHasBeenSet = true; m_subnetIds = std::move(value); }
+
+    /**
+     * <p>A list of VPC subnet IDs for the subnet group.</p>
+     */
+    inline CreateSubnetGroupRequest& WithSubnetIds(const Aws::Vector<Aws::String>& value) { SetSubnetIds(value); return *this;}
+
+    /**
+     * <p>A list of VPC subnet IDs for the subnet group.</p>
+     */
+    inline CreateSubnetGroupRequest& WithSubnetIds(Aws::Vector<Aws::String>&& value) { SetSubnetIds(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of VPC subnet IDs for the subnet group.</p>
+     */
+    inline CreateSubnetGroupRequest& AddSubnetIds(const Aws::String& value) { m_subnetIdsHasBeenSet = true; m_subnetIds.push_back(value); return *this; }
+
+    /**
+     * <p>A list of VPC subnet IDs for the subnet group.</p>
+     */
+    inline CreateSubnetGroupRequest& AddSubnetIds(Aws::String&& value) { m_subnetIdsHasBeenSet = true; m_subnetIds.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>A list of VPC subnet IDs for the subnet group.</p>
+     */
+    inline CreateSubnetGroupRequest& AddSubnetIds(const char* value) { m_subnetIdsHasBeenSet = true; m_subnetIds.push_back(value); return *this; }
+
+  private:
+
+    Aws::String m_subnetGroupName;
+    bool m_subnetGroupNameHasBeenSet;
+
+    Aws::String m_description;
+    bool m_descriptionHasBeenSet;
+
+    Aws::Vector<Aws::String> m_subnetIds;
+    bool m_subnetIdsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/CreateSubnetGroupResult.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/model/SubnetGroup.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+  class AWS_DAX_API CreateSubnetGroupResult
+  {
+  public:
+    CreateSubnetGroupResult();
+    CreateSubnetGroupResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    CreateSubnetGroupResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Represents the output of a <i>CreateSubnetGroup</i> operation.</p>
+     */
+    inline const SubnetGroup& GetSubnetGroup() const{ return m_subnetGroup; }
+
+    /**
+     * <p>Represents the output of a <i>CreateSubnetGroup</i> operation.</p>
+     */
+    inline void SetSubnetGroup(const SubnetGroup& value) { m_subnetGroup = value; }
+
+    /**
+     * <p>Represents the output of a <i>CreateSubnetGroup</i> operation.</p>
+     */
+    inline void SetSubnetGroup(SubnetGroup&& value) { m_subnetGroup = std::move(value); }
+
+    /**
+     * <p>Represents the output of a <i>CreateSubnetGroup</i> operation.</p>
+     */
+    inline CreateSubnetGroupResult& WithSubnetGroup(const SubnetGroup& value) { SetSubnetGroup(value); return *this;}
+
+    /**
+     * <p>Represents the output of a <i>CreateSubnetGroup</i> operation.</p>
+     */
+    inline CreateSubnetGroupResult& WithSubnetGroup(SubnetGroup&& value) { SetSubnetGroup(std::move(value)); return *this;}
+
+  private:
+
+    SubnetGroup m_subnetGroup;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/DecreaseReplicationFactorRequest.h

@@ -0,0 +1,208 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/DAXRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DAX_API DecreaseReplicationFactorRequest : public DAXRequest
+  {
+  public:
+    DecreaseReplicationFactorRequest();
+
+    // 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 "DecreaseReplicationFactor"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the DAX cluster from which you want to remove nodes.</p>
+     */
+    inline const Aws::String& GetClusterName() const{ return m_clusterName; }
+
+    /**
+     * <p>The name of the DAX cluster from which you want to remove nodes.</p>
+     */
+    inline bool ClusterNameHasBeenSet() const { return m_clusterNameHasBeenSet; }
+
+    /**
+     * <p>The name of the DAX cluster from which you want to remove nodes.</p>
+     */
+    inline void SetClusterName(const Aws::String& value) { m_clusterNameHasBeenSet = true; m_clusterName = value; }
+
+    /**
+     * <p>The name of the DAX cluster from which you want to remove nodes.</p>
+     */
+    inline void SetClusterName(Aws::String&& value) { m_clusterNameHasBeenSet = true; m_clusterName = std::move(value); }
+
+    /**
+     * <p>The name of the DAX cluster from which you want to remove nodes.</p>
+     */
+    inline void SetClusterName(const char* value) { m_clusterNameHasBeenSet = true; m_clusterName.assign(value); }
+
+    /**
+     * <p>The name of the DAX cluster from which you want to remove nodes.</p>
+     */
+    inline DecreaseReplicationFactorRequest& WithClusterName(const Aws::String& value) { SetClusterName(value); return *this;}
+
+    /**
+     * <p>The name of the DAX cluster from which you want to remove nodes.</p>
+     */
+    inline DecreaseReplicationFactorRequest& WithClusterName(Aws::String&& value) { SetClusterName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the DAX cluster from which you want to remove nodes.</p>
+     */
+    inline DecreaseReplicationFactorRequest& WithClusterName(const char* value) { SetClusterName(value); return *this;}
+
+
+    /**
+     * <p>The new number of nodes for the DAX cluster.</p>
+     */
+    inline int GetNewReplicationFactor() const{ return m_newReplicationFactor; }
+
+    /**
+     * <p>The new number of nodes for the DAX cluster.</p>
+     */
+    inline bool NewReplicationFactorHasBeenSet() const { return m_newReplicationFactorHasBeenSet; }
+
+    /**
+     * <p>The new number of nodes for the DAX cluster.</p>
+     */
+    inline void SetNewReplicationFactor(int value) { m_newReplicationFactorHasBeenSet = true; m_newReplicationFactor = value; }
+
+    /**
+     * <p>The new number of nodes for the DAX cluster.</p>
+     */
+    inline DecreaseReplicationFactorRequest& WithNewReplicationFactor(int value) { SetNewReplicationFactor(value); return *this;}
+
+
+    /**
+     * <p>The Availability Zone(s) from which to remove nodes.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetAvailabilityZones() const{ return m_availabilityZones; }
+
+    /**
+     * <p>The Availability Zone(s) from which to remove nodes.</p>
+     */
+    inline bool AvailabilityZonesHasBeenSet() const { return m_availabilityZonesHasBeenSet; }
+
+    /**
+     * <p>The Availability Zone(s) from which to remove nodes.</p>
+     */
+    inline void SetAvailabilityZones(const Aws::Vector<Aws::String>& value) { m_availabilityZonesHasBeenSet = true; m_availabilityZones = value; }
+
+    /**
+     * <p>The Availability Zone(s) from which to remove nodes.</p>
+     */
+    inline void SetAvailabilityZones(Aws::Vector<Aws::String>&& value) { m_availabilityZonesHasBeenSet = true; m_availabilityZones = std::move(value); }
+
+    /**
+     * <p>The Availability Zone(s) from which to remove nodes.</p>
+     */
+    inline DecreaseReplicationFactorRequest& WithAvailabilityZones(const Aws::Vector<Aws::String>& value) { SetAvailabilityZones(value); return *this;}
+
+    /**
+     * <p>The Availability Zone(s) from which to remove nodes.</p>
+     */
+    inline DecreaseReplicationFactorRequest& WithAvailabilityZones(Aws::Vector<Aws::String>&& value) { SetAvailabilityZones(std::move(value)); return *this;}
+
+    /**
+     * <p>The Availability Zone(s) from which to remove nodes.</p>
+     */
+    inline DecreaseReplicationFactorRequest& AddAvailabilityZones(const Aws::String& value) { m_availabilityZonesHasBeenSet = true; m_availabilityZones.push_back(value); return *this; }
+
+    /**
+     * <p>The Availability Zone(s) from which to remove nodes.</p>
+     */
+    inline DecreaseReplicationFactorRequest& AddAvailabilityZones(Aws::String&& value) { m_availabilityZonesHasBeenSet = true; m_availabilityZones.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>The Availability Zone(s) from which to remove nodes.</p>
+     */
+    inline DecreaseReplicationFactorRequest& AddAvailabilityZones(const char* value) { m_availabilityZonesHasBeenSet = true; m_availabilityZones.push_back(value); return *this; }
+
+
+    /**
+     * <p>The unique identifiers of the nodes to be removed from the cluster.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetNodeIdsToRemove() const{ return m_nodeIdsToRemove; }
+
+    /**
+     * <p>The unique identifiers of the nodes to be removed from the cluster.</p>
+     */
+    inline bool NodeIdsToRemoveHasBeenSet() const { return m_nodeIdsToRemoveHasBeenSet; }
+
+    /**
+     * <p>The unique identifiers of the nodes to be removed from the cluster.</p>
+     */
+    inline void SetNodeIdsToRemove(const Aws::Vector<Aws::String>& value) { m_nodeIdsToRemoveHasBeenSet = true; m_nodeIdsToRemove = value; }
+
+    /**
+     * <p>The unique identifiers of the nodes to be removed from the cluster.</p>
+     */
+    inline void SetNodeIdsToRemove(Aws::Vector<Aws::String>&& value) { m_nodeIdsToRemoveHasBeenSet = true; m_nodeIdsToRemove = std::move(value); }
+
+    /**
+     * <p>The unique identifiers of the nodes to be removed from the cluster.</p>
+     */
+    inline DecreaseReplicationFactorRequest& WithNodeIdsToRemove(const Aws::Vector<Aws::String>& value) { SetNodeIdsToRemove(value); return *this;}
+
+    /**
+     * <p>The unique identifiers of the nodes to be removed from the cluster.</p>
+     */
+    inline DecreaseReplicationFactorRequest& WithNodeIdsToRemove(Aws::Vector<Aws::String>&& value) { SetNodeIdsToRemove(std::move(value)); return *this;}
+
+    /**
+     * <p>The unique identifiers of the nodes to be removed from the cluster.</p>
+     */
+    inline DecreaseReplicationFactorRequest& AddNodeIdsToRemove(const Aws::String& value) { m_nodeIdsToRemoveHasBeenSet = true; m_nodeIdsToRemove.push_back(value); return *this; }
+
+    /**
+     * <p>The unique identifiers of the nodes to be removed from the cluster.</p>
+     */
+    inline DecreaseReplicationFactorRequest& AddNodeIdsToRemove(Aws::String&& value) { m_nodeIdsToRemoveHasBeenSet = true; m_nodeIdsToRemove.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>The unique identifiers of the nodes to be removed from the cluster.</p>
+     */
+    inline DecreaseReplicationFactorRequest& AddNodeIdsToRemove(const char* value) { m_nodeIdsToRemoveHasBeenSet = true; m_nodeIdsToRemove.push_back(value); return *this; }
+
+  private:
+
+    Aws::String m_clusterName;
+    bool m_clusterNameHasBeenSet;
+
+    int m_newReplicationFactor;
+    bool m_newReplicationFactorHasBeenSet;
+
+    Aws::Vector<Aws::String> m_availabilityZones;
+    bool m_availabilityZonesHasBeenSet;
+
+    Aws::Vector<Aws::String> m_nodeIdsToRemove;
+    bool m_nodeIdsToRemoveHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/DecreaseReplicationFactorResult.h

@@ -0,0 +1,72 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/model/Cluster.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+  class AWS_DAX_API DecreaseReplicationFactorResult
+  {
+  public:
+    DecreaseReplicationFactorResult();
+    DecreaseReplicationFactorResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DecreaseReplicationFactorResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>A description of the DAX cluster, after you have decreased its replication
+     * factor.</p>
+     */
+    inline const Cluster& GetCluster() const{ return m_cluster; }
+
+    /**
+     * <p>A description of the DAX cluster, after you have decreased its replication
+     * factor.</p>
+     */
+    inline void SetCluster(const Cluster& value) { m_cluster = value; }
+
+    /**
+     * <p>A description of the DAX cluster, after you have decreased its replication
+     * factor.</p>
+     */
+    inline void SetCluster(Cluster&& value) { m_cluster = std::move(value); }
+
+    /**
+     * <p>A description of the DAX cluster, after you have decreased its replication
+     * factor.</p>
+     */
+    inline DecreaseReplicationFactorResult& WithCluster(const Cluster& value) { SetCluster(value); return *this;}
+
+    /**
+     * <p>A description of the DAX cluster, after you have decreased its replication
+     * factor.</p>
+     */
+    inline DecreaseReplicationFactorResult& WithCluster(Cluster&& value) { SetCluster(std::move(value)); return *this;}
+
+  private:
+
+    Cluster m_cluster;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/DeleteClusterRequest.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/dax/DAX_EXPORTS.h>
+#include <aws/dax/DAXRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DAX_API DeleteClusterRequest : public DAXRequest
+  {
+  public:
+    DeleteClusterRequest();
+
+    // 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 "DeleteCluster"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the cluster to be deleted.</p>
+     */
+    inline const Aws::String& GetClusterName() const{ return m_clusterName; }
+
+    /**
+     * <p>The name of the cluster to be deleted.</p>
+     */
+    inline bool ClusterNameHasBeenSet() const { return m_clusterNameHasBeenSet; }
+
+    /**
+     * <p>The name of the cluster to be deleted.</p>
+     */
+    inline void SetClusterName(const Aws::String& value) { m_clusterNameHasBeenSet = true; m_clusterName = value; }
+
+    /**
+     * <p>The name of the cluster to be deleted.</p>
+     */
+    inline void SetClusterName(Aws::String&& value) { m_clusterNameHasBeenSet = true; m_clusterName = std::move(value); }
+
+    /**
+     * <p>The name of the cluster to be deleted.</p>
+     */
+    inline void SetClusterName(const char* value) { m_clusterNameHasBeenSet = true; m_clusterName.assign(value); }
+
+    /**
+     * <p>The name of the cluster to be deleted.</p>
+     */
+    inline DeleteClusterRequest& WithClusterName(const Aws::String& value) { SetClusterName(value); return *this;}
+
+    /**
+     * <p>The name of the cluster to be deleted.</p>
+     */
+    inline DeleteClusterRequest& WithClusterName(Aws::String&& value) { SetClusterName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the cluster to be deleted.</p>
+     */
+    inline DeleteClusterRequest& WithClusterName(const char* value) { SetClusterName(value); return *this;}
+
+  private:
+
+    Aws::String m_clusterName;
+    bool m_clusterNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/DeleteClusterResult.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/model/Cluster.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+  class AWS_DAX_API DeleteClusterResult
+  {
+  public:
+    DeleteClusterResult();
+    DeleteClusterResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DeleteClusterResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>A description of the DAX cluster that is being deleted.</p>
+     */
+    inline const Cluster& GetCluster() const{ return m_cluster; }
+
+    /**
+     * <p>A description of the DAX cluster that is being deleted.</p>
+     */
+    inline void SetCluster(const Cluster& value) { m_cluster = value; }
+
+    /**
+     * <p>A description of the DAX cluster that is being deleted.</p>
+     */
+    inline void SetCluster(Cluster&& value) { m_cluster = std::move(value); }
+
+    /**
+     * <p>A description of the DAX cluster that is being deleted.</p>
+     */
+    inline DeleteClusterResult& WithCluster(const Cluster& value) { SetCluster(value); return *this;}
+
+    /**
+     * <p>A description of the DAX cluster that is being deleted.</p>
+     */
+    inline DeleteClusterResult& WithCluster(Cluster&& value) { SetCluster(std::move(value)); return *this;}
+
+  private:
+
+    Cluster m_cluster;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/DeleteParameterGroupRequest.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/dax/DAX_EXPORTS.h>
+#include <aws/dax/DAXRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DAX_API DeleteParameterGroupRequest : public DAXRequest
+  {
+  public:
+    DeleteParameterGroupRequest();
+
+    // 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 "DeleteParameterGroup"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the parameter group to delete.</p>
+     */
+    inline const Aws::String& GetParameterGroupName() const{ return m_parameterGroupName; }
+
+    /**
+     * <p>The name of the parameter group to delete.</p>
+     */
+    inline bool ParameterGroupNameHasBeenSet() const { return m_parameterGroupNameHasBeenSet; }
+
+    /**
+     * <p>The name of the parameter group to delete.</p>
+     */
+    inline void SetParameterGroupName(const Aws::String& value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName = value; }
+
+    /**
+     * <p>The name of the parameter group to delete.</p>
+     */
+    inline void SetParameterGroupName(Aws::String&& value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName = std::move(value); }
+
+    /**
+     * <p>The name of the parameter group to delete.</p>
+     */
+    inline void SetParameterGroupName(const char* value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName.assign(value); }
+
+    /**
+     * <p>The name of the parameter group to delete.</p>
+     */
+    inline DeleteParameterGroupRequest& WithParameterGroupName(const Aws::String& value) { SetParameterGroupName(value); return *this;}
+
+    /**
+     * <p>The name of the parameter group to delete.</p>
+     */
+    inline DeleteParameterGroupRequest& WithParameterGroupName(Aws::String&& value) { SetParameterGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the parameter group to delete.</p>
+     */
+    inline DeleteParameterGroupRequest& WithParameterGroupName(const char* value) { SetParameterGroupName(value); return *this;}
+
+  private:
+
+    Aws::String m_parameterGroupName;
+    bool m_parameterGroupNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/DeleteParameterGroupResult.h

@@ -0,0 +1,84 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+  class AWS_DAX_API DeleteParameterGroupResult
+  {
+  public:
+    DeleteParameterGroupResult();
+    DeleteParameterGroupResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DeleteParameterGroupResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>A user-specified message for this action (i.e., a reason for deleting the
+     * parameter group).</p>
+     */
+    inline const Aws::String& GetDeletionMessage() const{ return m_deletionMessage; }
+
+    /**
+     * <p>A user-specified message for this action (i.e., a reason for deleting the
+     * parameter group).</p>
+     */
+    inline void SetDeletionMessage(const Aws::String& value) { m_deletionMessage = value; }
+
+    /**
+     * <p>A user-specified message for this action (i.e., a reason for deleting the
+     * parameter group).</p>
+     */
+    inline void SetDeletionMessage(Aws::String&& value) { m_deletionMessage = std::move(value); }
+
+    /**
+     * <p>A user-specified message for this action (i.e., a reason for deleting the
+     * parameter group).</p>
+     */
+    inline void SetDeletionMessage(const char* value) { m_deletionMessage.assign(value); }
+
+    /**
+     * <p>A user-specified message for this action (i.e., a reason for deleting the
+     * parameter group).</p>
+     */
+    inline DeleteParameterGroupResult& WithDeletionMessage(const Aws::String& value) { SetDeletionMessage(value); return *this;}
+
+    /**
+     * <p>A user-specified message for this action (i.e., a reason for deleting the
+     * parameter group).</p>
+     */
+    inline DeleteParameterGroupResult& WithDeletionMessage(Aws::String&& value) { SetDeletionMessage(std::move(value)); return *this;}
+
+    /**
+     * <p>A user-specified message for this action (i.e., a reason for deleting the
+     * parameter group).</p>
+     */
+    inline DeleteParameterGroupResult& WithDeletionMessage(const char* value) { SetDeletionMessage(value); return *this;}
+
+  private:
+
+    Aws::String m_deletionMessage;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/DeleteSubnetGroupRequest.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/dax/DAX_EXPORTS.h>
+#include <aws/dax/DAXRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DAX_API DeleteSubnetGroupRequest : public DAXRequest
+  {
+  public:
+    DeleteSubnetGroupRequest();
+
+    // 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 "DeleteSubnetGroup"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the subnet group to delete.</p>
+     */
+    inline const Aws::String& GetSubnetGroupName() const{ return m_subnetGroupName; }
+
+    /**
+     * <p>The name of the subnet group to delete.</p>
+     */
+    inline bool SubnetGroupNameHasBeenSet() const { return m_subnetGroupNameHasBeenSet; }
+
+    /**
+     * <p>The name of the subnet group to delete.</p>
+     */
+    inline void SetSubnetGroupName(const Aws::String& value) { m_subnetGroupNameHasBeenSet = true; m_subnetGroupName = value; }
+
+    /**
+     * <p>The name of the subnet group to delete.</p>
+     */
+    inline void SetSubnetGroupName(Aws::String&& value) { m_subnetGroupNameHasBeenSet = true; m_subnetGroupName = std::move(value); }
+
+    /**
+     * <p>The name of the subnet group to delete.</p>
+     */
+    inline void SetSubnetGroupName(const char* value) { m_subnetGroupNameHasBeenSet = true; m_subnetGroupName.assign(value); }
+
+    /**
+     * <p>The name of the subnet group to delete.</p>
+     */
+    inline DeleteSubnetGroupRequest& WithSubnetGroupName(const Aws::String& value) { SetSubnetGroupName(value); return *this;}
+
+    /**
+     * <p>The name of the subnet group to delete.</p>
+     */
+    inline DeleteSubnetGroupRequest& WithSubnetGroupName(Aws::String&& value) { SetSubnetGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the subnet group to delete.</p>
+     */
+    inline DeleteSubnetGroupRequest& WithSubnetGroupName(const char* value) { SetSubnetGroupName(value); return *this;}
+
+  private:
+
+    Aws::String m_subnetGroupName;
+    bool m_subnetGroupNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/DeleteSubnetGroupResult.h

@@ -0,0 +1,84 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+  class AWS_DAX_API DeleteSubnetGroupResult
+  {
+  public:
+    DeleteSubnetGroupResult();
+    DeleteSubnetGroupResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DeleteSubnetGroupResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>A user-specified message for this action (i.e., a reason for deleting the
+     * subnet group).</p>
+     */
+    inline const Aws::String& GetDeletionMessage() const{ return m_deletionMessage; }
+
+    /**
+     * <p>A user-specified message for this action (i.e., a reason for deleting the
+     * subnet group).</p>
+     */
+    inline void SetDeletionMessage(const Aws::String& value) { m_deletionMessage = value; }
+
+    /**
+     * <p>A user-specified message for this action (i.e., a reason for deleting the
+     * subnet group).</p>
+     */
+    inline void SetDeletionMessage(Aws::String&& value) { m_deletionMessage = std::move(value); }
+
+    /**
+     * <p>A user-specified message for this action (i.e., a reason for deleting the
+     * subnet group).</p>
+     */
+    inline void SetDeletionMessage(const char* value) { m_deletionMessage.assign(value); }
+
+    /**
+     * <p>A user-specified message for this action (i.e., a reason for deleting the
+     * subnet group).</p>
+     */
+    inline DeleteSubnetGroupResult& WithDeletionMessage(const Aws::String& value) { SetDeletionMessage(value); return *this;}
+
+    /**
+     * <p>A user-specified message for this action (i.e., a reason for deleting the
+     * subnet group).</p>
+     */
+    inline DeleteSubnetGroupResult& WithDeletionMessage(Aws::String&& value) { SetDeletionMessage(std::move(value)); return *this;}
+
+    /**
+     * <p>A user-specified message for this action (i.e., a reason for deleting the
+     * subnet group).</p>
+     */
+    inline DeleteSubnetGroupResult& WithDeletionMessage(const char* value) { SetDeletionMessage(value); return *this;}
+
+  private:
+
+    Aws::String m_deletionMessage;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/DescribeClustersRequest.h

@@ -0,0 +1,195 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/DAXRequest.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DAX_API DescribeClustersRequest : public DAXRequest
+  {
+  public:
+    DescribeClustersRequest();
+
+    // 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 "DescribeClusters"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The names of the DAX clusters being described.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetClusterNames() const{ return m_clusterNames; }
+
+    /**
+     * <p>The names of the DAX clusters being described.</p>
+     */
+    inline bool ClusterNamesHasBeenSet() const { return m_clusterNamesHasBeenSet; }
+
+    /**
+     * <p>The names of the DAX clusters being described.</p>
+     */
+    inline void SetClusterNames(const Aws::Vector<Aws::String>& value) { m_clusterNamesHasBeenSet = true; m_clusterNames = value; }
+
+    /**
+     * <p>The names of the DAX clusters being described.</p>
+     */
+    inline void SetClusterNames(Aws::Vector<Aws::String>&& value) { m_clusterNamesHasBeenSet = true; m_clusterNames = std::move(value); }
+
+    /**
+     * <p>The names of the DAX clusters being described.</p>
+     */
+    inline DescribeClustersRequest& WithClusterNames(const Aws::Vector<Aws::String>& value) { SetClusterNames(value); return *this;}
+
+    /**
+     * <p>The names of the DAX clusters being described.</p>
+     */
+    inline DescribeClustersRequest& WithClusterNames(Aws::Vector<Aws::String>&& value) { SetClusterNames(std::move(value)); return *this;}
+
+    /**
+     * <p>The names of the DAX clusters being described.</p>
+     */
+    inline DescribeClustersRequest& AddClusterNames(const Aws::String& value) { m_clusterNamesHasBeenSet = true; m_clusterNames.push_back(value); return *this; }
+
+    /**
+     * <p>The names of the DAX clusters being described.</p>
+     */
+    inline DescribeClustersRequest& AddClusterNames(Aws::String&& value) { m_clusterNamesHasBeenSet = true; m_clusterNames.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>The names of the DAX clusters being described.</p>
+     */
+    inline DescribeClustersRequest& AddClusterNames(const char* value) { m_clusterNamesHasBeenSet = true; m_clusterNames.push_back(value); return *this; }
+
+
+    /**
+     * <p>The maximum number of results to include in the response. If more results
+     * exist than the specified <code>MaxResults</code> value, a token is included in
+     * the response so that the remaining results can be retrieved.</p> <p>The value
+     * for <code>MaxResults</code> must be between 20 and 100.</p>
+     */
+    inline int GetMaxResults() const{ return m_maxResults; }
+
+    /**
+     * <p>The maximum number of results to include in the response. If more results
+     * exist than the specified <code>MaxResults</code> value, a token is included in
+     * the response so that the remaining results can be retrieved.</p> <p>The value
+     * for <code>MaxResults</code> must be between 20 and 100.</p>
+     */
+    inline bool MaxResultsHasBeenSet() const { return m_maxResultsHasBeenSet; }
+
+    /**
+     * <p>The maximum number of results to include in the response. If more results
+     * exist than the specified <code>MaxResults</code> value, a token is included in
+     * the response so that the remaining results can be retrieved.</p> <p>The value
+     * for <code>MaxResults</code> must be between 20 and 100.</p>
+     */
+    inline void SetMaxResults(int value) { m_maxResultsHasBeenSet = true; m_maxResults = value; }
+
+    /**
+     * <p>The maximum number of results to include in the response. If more results
+     * exist than the specified <code>MaxResults</code> value, a token is included in
+     * the response so that the remaining results can be retrieved.</p> <p>The value
+     * for <code>MaxResults</code> must be between 20 and 100.</p>
+     */
+    inline DescribeClustersRequest& WithMaxResults(int value) { SetMaxResults(value); return *this;}
+
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline DescribeClustersRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline DescribeClustersRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline DescribeClustersRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+  private:
+
+    Aws::Vector<Aws::String> m_clusterNames;
+    bool m_clusterNamesHasBeenSet;
+
+    int m_maxResults;
+    bool m_maxResultsHasBeenSet;
+
+    Aws::String m_nextToken;
+    bool m_nextTokenHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/DescribeClustersResult.h

@@ -0,0 +1,124 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/dax/model/Cluster.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+  class AWS_DAX_API DescribeClustersResult
+  {
+  public:
+    DescribeClustersResult();
+    DescribeClustersResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DescribeClustersResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline DescribeClustersResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline DescribeClustersResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline DescribeClustersResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>The descriptions of your DAX clusters, in response to a
+     * <i>DescribeClusters</i> request.</p>
+     */
+    inline const Aws::Vector<Cluster>& GetClusters() const{ return m_clusters; }
+
+    /**
+     * <p>The descriptions of your DAX clusters, in response to a
+     * <i>DescribeClusters</i> request.</p>
+     */
+    inline void SetClusters(const Aws::Vector<Cluster>& value) { m_clusters = value; }
+
+    /**
+     * <p>The descriptions of your DAX clusters, in response to a
+     * <i>DescribeClusters</i> request.</p>
+     */
+    inline void SetClusters(Aws::Vector<Cluster>&& value) { m_clusters = std::move(value); }
+
+    /**
+     * <p>The descriptions of your DAX clusters, in response to a
+     * <i>DescribeClusters</i> request.</p>
+     */
+    inline DescribeClustersResult& WithClusters(const Aws::Vector<Cluster>& value) { SetClusters(value); return *this;}
+
+    /**
+     * <p>The descriptions of your DAX clusters, in response to a
+     * <i>DescribeClusters</i> request.</p>
+     */
+    inline DescribeClustersResult& WithClusters(Aws::Vector<Cluster>&& value) { SetClusters(std::move(value)); return *this;}
+
+    /**
+     * <p>The descriptions of your DAX clusters, in response to a
+     * <i>DescribeClusters</i> request.</p>
+     */
+    inline DescribeClustersResult& AddClusters(const Cluster& value) { m_clusters.push_back(value); return *this; }
+
+    /**
+     * <p>The descriptions of your DAX clusters, in response to a
+     * <i>DescribeClusters</i> request.</p>
+     */
+    inline DescribeClustersResult& AddClusters(Cluster&& value) { m_clusters.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_nextToken;
+
+    Aws::Vector<Cluster> m_clusters;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/DescribeDefaultParametersRequest.h

@@ -0,0 +1,145 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/DAXRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DAX_API DescribeDefaultParametersRequest : public DAXRequest
+  {
+  public:
+    DescribeDefaultParametersRequest();
+
+    // 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 "DescribeDefaultParameters"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The maximum number of results to include in the response. If more results
+     * exist than the specified <code>MaxResults</code> value, a token is included in
+     * the response so that the remaining results can be retrieved.</p> <p>The value
+     * for <code>MaxResults</code> must be between 20 and 100.</p>
+     */
+    inline int GetMaxResults() const{ return m_maxResults; }
+
+    /**
+     * <p>The maximum number of results to include in the response. If more results
+     * exist than the specified <code>MaxResults</code> value, a token is included in
+     * the response so that the remaining results can be retrieved.</p> <p>The value
+     * for <code>MaxResults</code> must be between 20 and 100.</p>
+     */
+    inline bool MaxResultsHasBeenSet() const { return m_maxResultsHasBeenSet; }
+
+    /**
+     * <p>The maximum number of results to include in the response. If more results
+     * exist than the specified <code>MaxResults</code> value, a token is included in
+     * the response so that the remaining results can be retrieved.</p> <p>The value
+     * for <code>MaxResults</code> must be between 20 and 100.</p>
+     */
+    inline void SetMaxResults(int value) { m_maxResultsHasBeenSet = true; m_maxResults = value; }
+
+    /**
+     * <p>The maximum number of results to include in the response. If more results
+     * exist than the specified <code>MaxResults</code> value, a token is included in
+     * the response so that the remaining results can be retrieved.</p> <p>The value
+     * for <code>MaxResults</code> must be between 20 and 100.</p>
+     */
+    inline DescribeDefaultParametersRequest& WithMaxResults(int value) { SetMaxResults(value); return *this;}
+
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline DescribeDefaultParametersRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline DescribeDefaultParametersRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline DescribeDefaultParametersRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+  private:
+
+    int m_maxResults;
+    bool m_maxResultsHasBeenSet;
+
+    Aws::String m_nextToken;
+    bool m_nextTokenHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/DescribeDefaultParametersResult.h

@@ -0,0 +1,117 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/dax/model/Parameter.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+  class AWS_DAX_API DescribeDefaultParametersResult
+  {
+  public:
+    DescribeDefaultParametersResult();
+    DescribeDefaultParametersResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DescribeDefaultParametersResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline DescribeDefaultParametersResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline DescribeDefaultParametersResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline DescribeDefaultParametersResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>A list of parameters. Each element in the list represents one parameter.</p>
+     */
+    inline const Aws::Vector<Parameter>& GetParameters() const{ return m_parameters; }
+
+    /**
+     * <p>A list of parameters. Each element in the list represents one parameter.</p>
+     */
+    inline void SetParameters(const Aws::Vector<Parameter>& value) { m_parameters = value; }
+
+    /**
+     * <p>A list of parameters. Each element in the list represents one parameter.</p>
+     */
+    inline void SetParameters(Aws::Vector<Parameter>&& value) { m_parameters = std::move(value); }
+
+    /**
+     * <p>A list of parameters. Each element in the list represents one parameter.</p>
+     */
+    inline DescribeDefaultParametersResult& WithParameters(const Aws::Vector<Parameter>& value) { SetParameters(value); return *this;}
+
+    /**
+     * <p>A list of parameters. Each element in the list represents one parameter.</p>
+     */
+    inline DescribeDefaultParametersResult& WithParameters(Aws::Vector<Parameter>&& value) { SetParameters(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of parameters. Each element in the list represents one parameter.</p>
+     */
+    inline DescribeDefaultParametersResult& AddParameters(const Parameter& value) { m_parameters.push_back(value); return *this; }
+
+    /**
+     * <p>A list of parameters. Each element in the list represents one parameter.</p>
+     */
+    inline DescribeDefaultParametersResult& AddParameters(Parameter&& value) { m_parameters.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_nextToken;
+
+    Aws::Vector<Parameter> m_parameters;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/DescribeEventsRequest.h

@@ -0,0 +1,343 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/DAXRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/dax/model/SourceType.h>
+#include <aws/core/utils/DateTime.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DAX_API DescribeEventsRequest : public DAXRequest
+  {
+  public:
+    DescribeEventsRequest();
+
+    // 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 "DescribeEvents"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The identifier of the event source for which events will be returned. If not
+     * specified, then all sources are included in the response.</p>
+     */
+    inline const Aws::String& GetSourceName() const{ return m_sourceName; }
+
+    /**
+     * <p>The identifier of the event source for which events will be returned. If not
+     * specified, then all sources are included in the response.</p>
+     */
+    inline bool SourceNameHasBeenSet() const { return m_sourceNameHasBeenSet; }
+
+    /**
+     * <p>The identifier of the event source for which events will be returned. If not
+     * specified, then all sources are included in the response.</p>
+     */
+    inline void SetSourceName(const Aws::String& value) { m_sourceNameHasBeenSet = true; m_sourceName = value; }
+
+    /**
+     * <p>The identifier of the event source for which events will be returned. If not
+     * specified, then all sources are included in the response.</p>
+     */
+    inline void SetSourceName(Aws::String&& value) { m_sourceNameHasBeenSet = true; m_sourceName = std::move(value); }
+
+    /**
+     * <p>The identifier of the event source for which events will be returned. If not
+     * specified, then all sources are included in the response.</p>
+     */
+    inline void SetSourceName(const char* value) { m_sourceNameHasBeenSet = true; m_sourceName.assign(value); }
+
+    /**
+     * <p>The identifier of the event source for which events will be returned. If not
+     * specified, then all sources are included in the response.</p>
+     */
+    inline DescribeEventsRequest& WithSourceName(const Aws::String& value) { SetSourceName(value); return *this;}
+
+    /**
+     * <p>The identifier of the event source for which events will be returned. If not
+     * specified, then all sources are included in the response.</p>
+     */
+    inline DescribeEventsRequest& WithSourceName(Aws::String&& value) { SetSourceName(std::move(value)); return *this;}
+
+    /**
+     * <p>The identifier of the event source for which events will be returned. If not
+     * specified, then all sources are included in the response.</p>
+     */
+    inline DescribeEventsRequest& WithSourceName(const char* value) { SetSourceName(value); return *this;}
+
+
+    /**
+     * <p>The event source to retrieve events for. If no value is specified, all events
+     * are returned.</p>
+     */
+    inline const SourceType& GetSourceType() const{ return m_sourceType; }
+
+    /**
+     * <p>The event source to retrieve events for. If no value is specified, all events
+     * are returned.</p>
+     */
+    inline bool SourceTypeHasBeenSet() const { return m_sourceTypeHasBeenSet; }
+
+    /**
+     * <p>The event source to retrieve events for. If no value is specified, all events
+     * are returned.</p>
+     */
+    inline void SetSourceType(const SourceType& value) { m_sourceTypeHasBeenSet = true; m_sourceType = value; }
+
+    /**
+     * <p>The event source to retrieve events for. If no value is specified, all events
+     * are returned.</p>
+     */
+    inline void SetSourceType(SourceType&& value) { m_sourceTypeHasBeenSet = true; m_sourceType = std::move(value); }
+
+    /**
+     * <p>The event source to retrieve events for. If no value is specified, all events
+     * are returned.</p>
+     */
+    inline DescribeEventsRequest& WithSourceType(const SourceType& value) { SetSourceType(value); return *this;}
+
+    /**
+     * <p>The event source to retrieve events for. If no value is specified, all events
+     * are returned.</p>
+     */
+    inline DescribeEventsRequest& WithSourceType(SourceType&& value) { SetSourceType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The beginning of the time interval to retrieve events for, specified in ISO
+     * 8601 format.</p>
+     */
+    inline const Aws::Utils::DateTime& GetStartTime() const{ return m_startTime; }
+
+    /**
+     * <p>The beginning of the time interval to retrieve events for, specified in ISO
+     * 8601 format.</p>
+     */
+    inline bool StartTimeHasBeenSet() const { return m_startTimeHasBeenSet; }
+
+    /**
+     * <p>The beginning of the time interval to retrieve events for, specified in ISO
+     * 8601 format.</p>
+     */
+    inline void SetStartTime(const Aws::Utils::DateTime& value) { m_startTimeHasBeenSet = true; m_startTime = value; }
+
+    /**
+     * <p>The beginning of the time interval to retrieve events for, specified in ISO
+     * 8601 format.</p>
+     */
+    inline void SetStartTime(Aws::Utils::DateTime&& value) { m_startTimeHasBeenSet = true; m_startTime = std::move(value); }
+
+    /**
+     * <p>The beginning of the time interval to retrieve events for, specified in ISO
+     * 8601 format.</p>
+     */
+    inline DescribeEventsRequest& WithStartTime(const Aws::Utils::DateTime& value) { SetStartTime(value); return *this;}
+
+    /**
+     * <p>The beginning of the time interval to retrieve events for, specified in ISO
+     * 8601 format.</p>
+     */
+    inline DescribeEventsRequest& WithStartTime(Aws::Utils::DateTime&& value) { SetStartTime(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The end of the time interval for which to retrieve events, specified in ISO
+     * 8601 format.</p>
+     */
+    inline const Aws::Utils::DateTime& GetEndTime() const{ return m_endTime; }
+
+    /**
+     * <p>The end of the time interval for which to retrieve events, specified in ISO
+     * 8601 format.</p>
+     */
+    inline bool EndTimeHasBeenSet() const { return m_endTimeHasBeenSet; }
+
+    /**
+     * <p>The end of the time interval for which to retrieve events, specified in ISO
+     * 8601 format.</p>
+     */
+    inline void SetEndTime(const Aws::Utils::DateTime& value) { m_endTimeHasBeenSet = true; m_endTime = value; }
+
+    /**
+     * <p>The end of the time interval for which to retrieve events, specified in ISO
+     * 8601 format.</p>
+     */
+    inline void SetEndTime(Aws::Utils::DateTime&& value) { m_endTimeHasBeenSet = true; m_endTime = std::move(value); }
+
+    /**
+     * <p>The end of the time interval for which to retrieve events, specified in ISO
+     * 8601 format.</p>
+     */
+    inline DescribeEventsRequest& WithEndTime(const Aws::Utils::DateTime& value) { SetEndTime(value); return *this;}
+
+    /**
+     * <p>The end of the time interval for which to retrieve events, specified in ISO
+     * 8601 format.</p>
+     */
+    inline DescribeEventsRequest& WithEndTime(Aws::Utils::DateTime&& value) { SetEndTime(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The number of minutes' worth of events to retrieve.</p>
+     */
+    inline int GetDuration() const{ return m_duration; }
+
+    /**
+     * <p>The number of minutes' worth of events to retrieve.</p>
+     */
+    inline bool DurationHasBeenSet() const { return m_durationHasBeenSet; }
+
+    /**
+     * <p>The number of minutes' worth of events to retrieve.</p>
+     */
+    inline void SetDuration(int value) { m_durationHasBeenSet = true; m_duration = value; }
+
+    /**
+     * <p>The number of minutes' worth of events to retrieve.</p>
+     */
+    inline DescribeEventsRequest& WithDuration(int value) { SetDuration(value); return *this;}
+
+
+    /**
+     * <p>The maximum number of results to include in the response. If more results
+     * exist than the specified <code>MaxResults</code> value, a token is included in
+     * the response so that the remaining results can be retrieved.</p> <p>The value
+     * for <code>MaxResults</code> must be between 20 and 100.</p>
+     */
+    inline int GetMaxResults() const{ return m_maxResults; }
+
+    /**
+     * <p>The maximum number of results to include in the response. If more results
+     * exist than the specified <code>MaxResults</code> value, a token is included in
+     * the response so that the remaining results can be retrieved.</p> <p>The value
+     * for <code>MaxResults</code> must be between 20 and 100.</p>
+     */
+    inline bool MaxResultsHasBeenSet() const { return m_maxResultsHasBeenSet; }
+
+    /**
+     * <p>The maximum number of results to include in the response. If more results
+     * exist than the specified <code>MaxResults</code> value, a token is included in
+     * the response so that the remaining results can be retrieved.</p> <p>The value
+     * for <code>MaxResults</code> must be between 20 and 100.</p>
+     */
+    inline void SetMaxResults(int value) { m_maxResultsHasBeenSet = true; m_maxResults = value; }
+
+    /**
+     * <p>The maximum number of results to include in the response. If more results
+     * exist than the specified <code>MaxResults</code> value, a token is included in
+     * the response so that the remaining results can be retrieved.</p> <p>The value
+     * for <code>MaxResults</code> must be between 20 and 100.</p>
+     */
+    inline DescribeEventsRequest& WithMaxResults(int value) { SetMaxResults(value); return *this;}
+
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline DescribeEventsRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline DescribeEventsRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline DescribeEventsRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+  private:
+
+    Aws::String m_sourceName;
+    bool m_sourceNameHasBeenSet;
+
+    SourceType m_sourceType;
+    bool m_sourceTypeHasBeenSet;
+
+    Aws::Utils::DateTime m_startTime;
+    bool m_startTimeHasBeenSet;
+
+    Aws::Utils::DateTime m_endTime;
+    bool m_endTimeHasBeenSet;
+
+    int m_duration;
+    bool m_durationHasBeenSet;
+
+    int m_maxResults;
+    bool m_maxResultsHasBeenSet;
+
+    Aws::String m_nextToken;
+    bool m_nextTokenHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/DescribeEventsResult.h

@@ -0,0 +1,117 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/dax/model/Event.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+  class AWS_DAX_API DescribeEventsResult
+  {
+  public:
+    DescribeEventsResult();
+    DescribeEventsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DescribeEventsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline DescribeEventsResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline DescribeEventsResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline DescribeEventsResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>An array of events. Each element in the array represents one event.</p>
+     */
+    inline const Aws::Vector<Event>& GetEvents() const{ return m_events; }
+
+    /**
+     * <p>An array of events. Each element in the array represents one event.</p>
+     */
+    inline void SetEvents(const Aws::Vector<Event>& value) { m_events = value; }
+
+    /**
+     * <p>An array of events. Each element in the array represents one event.</p>
+     */
+    inline void SetEvents(Aws::Vector<Event>&& value) { m_events = std::move(value); }
+
+    /**
+     * <p>An array of events. Each element in the array represents one event.</p>
+     */
+    inline DescribeEventsResult& WithEvents(const Aws::Vector<Event>& value) { SetEvents(value); return *this;}
+
+    /**
+     * <p>An array of events. Each element in the array represents one event.</p>
+     */
+    inline DescribeEventsResult& WithEvents(Aws::Vector<Event>&& value) { SetEvents(std::move(value)); return *this;}
+
+    /**
+     * <p>An array of events. Each element in the array represents one event.</p>
+     */
+    inline DescribeEventsResult& AddEvents(const Event& value) { m_events.push_back(value); return *this; }
+
+    /**
+     * <p>An array of events. Each element in the array represents one event.</p>
+     */
+    inline DescribeEventsResult& AddEvents(Event&& value) { m_events.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_nextToken;
+
+    Aws::Vector<Event> m_events;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/DescribeParameterGroupsRequest.h

@@ -0,0 +1,195 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/DAXRequest.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DAX_API DescribeParameterGroupsRequest : public DAXRequest
+  {
+  public:
+    DescribeParameterGroupsRequest();
+
+    // 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 "DescribeParameterGroups"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The names of the parameter groups.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetParameterGroupNames() const{ return m_parameterGroupNames; }
+
+    /**
+     * <p>The names of the parameter groups.</p>
+     */
+    inline bool ParameterGroupNamesHasBeenSet() const { return m_parameterGroupNamesHasBeenSet; }
+
+    /**
+     * <p>The names of the parameter groups.</p>
+     */
+    inline void SetParameterGroupNames(const Aws::Vector<Aws::String>& value) { m_parameterGroupNamesHasBeenSet = true; m_parameterGroupNames = value; }
+
+    /**
+     * <p>The names of the parameter groups.</p>
+     */
+    inline void SetParameterGroupNames(Aws::Vector<Aws::String>&& value) { m_parameterGroupNamesHasBeenSet = true; m_parameterGroupNames = std::move(value); }
+
+    /**
+     * <p>The names of the parameter groups.</p>
+     */
+    inline DescribeParameterGroupsRequest& WithParameterGroupNames(const Aws::Vector<Aws::String>& value) { SetParameterGroupNames(value); return *this;}
+
+    /**
+     * <p>The names of the parameter groups.</p>
+     */
+    inline DescribeParameterGroupsRequest& WithParameterGroupNames(Aws::Vector<Aws::String>&& value) { SetParameterGroupNames(std::move(value)); return *this;}
+
+    /**
+     * <p>The names of the parameter groups.</p>
+     */
+    inline DescribeParameterGroupsRequest& AddParameterGroupNames(const Aws::String& value) { m_parameterGroupNamesHasBeenSet = true; m_parameterGroupNames.push_back(value); return *this; }
+
+    /**
+     * <p>The names of the parameter groups.</p>
+     */
+    inline DescribeParameterGroupsRequest& AddParameterGroupNames(Aws::String&& value) { m_parameterGroupNamesHasBeenSet = true; m_parameterGroupNames.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>The names of the parameter groups.</p>
+     */
+    inline DescribeParameterGroupsRequest& AddParameterGroupNames(const char* value) { m_parameterGroupNamesHasBeenSet = true; m_parameterGroupNames.push_back(value); return *this; }
+
+
+    /**
+     * <p>The maximum number of results to include in the response. If more results
+     * exist than the specified <code>MaxResults</code> value, a token is included in
+     * the response so that the remaining results can be retrieved.</p> <p>The value
+     * for <code>MaxResults</code> must be between 20 and 100.</p>
+     */
+    inline int GetMaxResults() const{ return m_maxResults; }
+
+    /**
+     * <p>The maximum number of results to include in the response. If more results
+     * exist than the specified <code>MaxResults</code> value, a token is included in
+     * the response so that the remaining results can be retrieved.</p> <p>The value
+     * for <code>MaxResults</code> must be between 20 and 100.</p>
+     */
+    inline bool MaxResultsHasBeenSet() const { return m_maxResultsHasBeenSet; }
+
+    /**
+     * <p>The maximum number of results to include in the response. If more results
+     * exist than the specified <code>MaxResults</code> value, a token is included in
+     * the response so that the remaining results can be retrieved.</p> <p>The value
+     * for <code>MaxResults</code> must be between 20 and 100.</p>
+     */
+    inline void SetMaxResults(int value) { m_maxResultsHasBeenSet = true; m_maxResults = value; }
+
+    /**
+     * <p>The maximum number of results to include in the response. If more results
+     * exist than the specified <code>MaxResults</code> value, a token is included in
+     * the response so that the remaining results can be retrieved.</p> <p>The value
+     * for <code>MaxResults</code> must be between 20 and 100.</p>
+     */
+    inline DescribeParameterGroupsRequest& WithMaxResults(int value) { SetMaxResults(value); return *this;}
+
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline DescribeParameterGroupsRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline DescribeParameterGroupsRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline DescribeParameterGroupsRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+  private:
+
+    Aws::Vector<Aws::String> m_parameterGroupNames;
+    bool m_parameterGroupNamesHasBeenSet;
+
+    int m_maxResults;
+    bool m_maxResultsHasBeenSet;
+
+    Aws::String m_nextToken;
+    bool m_nextTokenHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/DescribeParameterGroupsResult.h

@@ -0,0 +1,124 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/dax/model/ParameterGroup.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+  class AWS_DAX_API DescribeParameterGroupsResult
+  {
+  public:
+    DescribeParameterGroupsResult();
+    DescribeParameterGroupsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DescribeParameterGroupsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline DescribeParameterGroupsResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline DescribeParameterGroupsResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline DescribeParameterGroupsResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>An array of parameter groups. Each element in the array represents one
+     * parameter group.</p>
+     */
+    inline const Aws::Vector<ParameterGroup>& GetParameterGroups() const{ return m_parameterGroups; }
+
+    /**
+     * <p>An array of parameter groups. Each element in the array represents one
+     * parameter group.</p>
+     */
+    inline void SetParameterGroups(const Aws::Vector<ParameterGroup>& value) { m_parameterGroups = value; }
+
+    /**
+     * <p>An array of parameter groups. Each element in the array represents one
+     * parameter group.</p>
+     */
+    inline void SetParameterGroups(Aws::Vector<ParameterGroup>&& value) { m_parameterGroups = std::move(value); }
+
+    /**
+     * <p>An array of parameter groups. Each element in the array represents one
+     * parameter group.</p>
+     */
+    inline DescribeParameterGroupsResult& WithParameterGroups(const Aws::Vector<ParameterGroup>& value) { SetParameterGroups(value); return *this;}
+
+    /**
+     * <p>An array of parameter groups. Each element in the array represents one
+     * parameter group.</p>
+     */
+    inline DescribeParameterGroupsResult& WithParameterGroups(Aws::Vector<ParameterGroup>&& value) { SetParameterGroups(std::move(value)); return *this;}
+
+    /**
+     * <p>An array of parameter groups. Each element in the array represents one
+     * parameter group.</p>
+     */
+    inline DescribeParameterGroupsResult& AddParameterGroups(const ParameterGroup& value) { m_parameterGroups.push_back(value); return *this; }
+
+    /**
+     * <p>An array of parameter groups. Each element in the array represents one
+     * parameter group.</p>
+     */
+    inline DescribeParameterGroupsResult& AddParameterGroups(ParameterGroup&& value) { m_parameterGroups.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_nextToken;
+
+    Aws::Vector<ParameterGroup> m_parameterGroups;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/DescribeParametersRequest.h

@@ -0,0 +1,241 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/DAXRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DAX_API DescribeParametersRequest : public DAXRequest
+  {
+  public:
+    DescribeParametersRequest();
+
+    // 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 "DescribeParameters"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline const Aws::String& GetParameterGroupName() const{ return m_parameterGroupName; }
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline bool ParameterGroupNameHasBeenSet() const { return m_parameterGroupNameHasBeenSet; }
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline void SetParameterGroupName(const Aws::String& value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName = value; }
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline void SetParameterGroupName(Aws::String&& value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName = std::move(value); }
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline void SetParameterGroupName(const char* value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName.assign(value); }
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline DescribeParametersRequest& WithParameterGroupName(const Aws::String& value) { SetParameterGroupName(value); return *this;}
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline DescribeParametersRequest& WithParameterGroupName(Aws::String&& value) { SetParameterGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline DescribeParametersRequest& WithParameterGroupName(const char* value) { SetParameterGroupName(value); return *this;}
+
+
+    /**
+     * <p>How the parameter is defined. For example, <code>system</code> denotes a
+     * system-defined parameter.</p>
+     */
+    inline const Aws::String& GetSource() const{ return m_source; }
+
+    /**
+     * <p>How the parameter is defined. For example, <code>system</code> denotes a
+     * system-defined parameter.</p>
+     */
+    inline bool SourceHasBeenSet() const { return m_sourceHasBeenSet; }
+
+    /**
+     * <p>How the parameter is defined. For example, <code>system</code> denotes a
+     * system-defined parameter.</p>
+     */
+    inline void SetSource(const Aws::String& value) { m_sourceHasBeenSet = true; m_source = value; }
+
+    /**
+     * <p>How the parameter is defined. For example, <code>system</code> denotes a
+     * system-defined parameter.</p>
+     */
+    inline void SetSource(Aws::String&& value) { m_sourceHasBeenSet = true; m_source = std::move(value); }
+
+    /**
+     * <p>How the parameter is defined. For example, <code>system</code> denotes a
+     * system-defined parameter.</p>
+     */
+    inline void SetSource(const char* value) { m_sourceHasBeenSet = true; m_source.assign(value); }
+
+    /**
+     * <p>How the parameter is defined. For example, <code>system</code> denotes a
+     * system-defined parameter.</p>
+     */
+    inline DescribeParametersRequest& WithSource(const Aws::String& value) { SetSource(value); return *this;}
+
+    /**
+     * <p>How the parameter is defined. For example, <code>system</code> denotes a
+     * system-defined parameter.</p>
+     */
+    inline DescribeParametersRequest& WithSource(Aws::String&& value) { SetSource(std::move(value)); return *this;}
+
+    /**
+     * <p>How the parameter is defined. For example, <code>system</code> denotes a
+     * system-defined parameter.</p>
+     */
+    inline DescribeParametersRequest& WithSource(const char* value) { SetSource(value); return *this;}
+
+
+    /**
+     * <p>The maximum number of results to include in the response. If more results
+     * exist than the specified <code>MaxResults</code> value, a token is included in
+     * the response so that the remaining results can be retrieved.</p> <p>The value
+     * for <code>MaxResults</code> must be between 20 and 100.</p>
+     */
+    inline int GetMaxResults() const{ return m_maxResults; }
+
+    /**
+     * <p>The maximum number of results to include in the response. If more results
+     * exist than the specified <code>MaxResults</code> value, a token is included in
+     * the response so that the remaining results can be retrieved.</p> <p>The value
+     * for <code>MaxResults</code> must be between 20 and 100.</p>
+     */
+    inline bool MaxResultsHasBeenSet() const { return m_maxResultsHasBeenSet; }
+
+    /**
+     * <p>The maximum number of results to include in the response. If more results
+     * exist than the specified <code>MaxResults</code> value, a token is included in
+     * the response so that the remaining results can be retrieved.</p> <p>The value
+     * for <code>MaxResults</code> must be between 20 and 100.</p>
+     */
+    inline void SetMaxResults(int value) { m_maxResultsHasBeenSet = true; m_maxResults = value; }
+
+    /**
+     * <p>The maximum number of results to include in the response. If more results
+     * exist than the specified <code>MaxResults</code> value, a token is included in
+     * the response so that the remaining results can be retrieved.</p> <p>The value
+     * for <code>MaxResults</code> must be between 20 and 100.</p>
+     */
+    inline DescribeParametersRequest& WithMaxResults(int value) { SetMaxResults(value); return *this;}
+
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline DescribeParametersRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline DescribeParametersRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline DescribeParametersRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+  private:
+
+    Aws::String m_parameterGroupName;
+    bool m_parameterGroupNameHasBeenSet;
+
+    Aws::String m_source;
+    bool m_sourceHasBeenSet;
+
+    int m_maxResults;
+    bool m_maxResultsHasBeenSet;
+
+    Aws::String m_nextToken;
+    bool m_nextTokenHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/DescribeParametersResult.h

@@ -0,0 +1,124 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/dax/model/Parameter.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+  class AWS_DAX_API DescribeParametersResult
+  {
+  public:
+    DescribeParametersResult();
+    DescribeParametersResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DescribeParametersResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline DescribeParametersResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline DescribeParametersResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline DescribeParametersResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>A list of parameters within a parameter group. Each element in the list
+     * represents one parameter.</p>
+     */
+    inline const Aws::Vector<Parameter>& GetParameters() const{ return m_parameters; }
+
+    /**
+     * <p>A list of parameters within a parameter group. Each element in the list
+     * represents one parameter.</p>
+     */
+    inline void SetParameters(const Aws::Vector<Parameter>& value) { m_parameters = value; }
+
+    /**
+     * <p>A list of parameters within a parameter group. Each element in the list
+     * represents one parameter.</p>
+     */
+    inline void SetParameters(Aws::Vector<Parameter>&& value) { m_parameters = std::move(value); }
+
+    /**
+     * <p>A list of parameters within a parameter group. Each element in the list
+     * represents one parameter.</p>
+     */
+    inline DescribeParametersResult& WithParameters(const Aws::Vector<Parameter>& value) { SetParameters(value); return *this;}
+
+    /**
+     * <p>A list of parameters within a parameter group. Each element in the list
+     * represents one parameter.</p>
+     */
+    inline DescribeParametersResult& WithParameters(Aws::Vector<Parameter>&& value) { SetParameters(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of parameters within a parameter group. Each element in the list
+     * represents one parameter.</p>
+     */
+    inline DescribeParametersResult& AddParameters(const Parameter& value) { m_parameters.push_back(value); return *this; }
+
+    /**
+     * <p>A list of parameters within a parameter group. Each element in the list
+     * represents one parameter.</p>
+     */
+    inline DescribeParametersResult& AddParameters(Parameter&& value) { m_parameters.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_nextToken;
+
+    Aws::Vector<Parameter> m_parameters;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/DescribeSubnetGroupsRequest.h

@@ -0,0 +1,195 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/DAXRequest.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DAX_API DescribeSubnetGroupsRequest : public DAXRequest
+  {
+  public:
+    DescribeSubnetGroupsRequest();
+
+    // 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 "DescribeSubnetGroups"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the subnet group.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetSubnetGroupNames() const{ return m_subnetGroupNames; }
+
+    /**
+     * <p>The name of the subnet group.</p>
+     */
+    inline bool SubnetGroupNamesHasBeenSet() const { return m_subnetGroupNamesHasBeenSet; }
+
+    /**
+     * <p>The name of the subnet group.</p>
+     */
+    inline void SetSubnetGroupNames(const Aws::Vector<Aws::String>& value) { m_subnetGroupNamesHasBeenSet = true; m_subnetGroupNames = value; }
+
+    /**
+     * <p>The name of the subnet group.</p>
+     */
+    inline void SetSubnetGroupNames(Aws::Vector<Aws::String>&& value) { m_subnetGroupNamesHasBeenSet = true; m_subnetGroupNames = std::move(value); }
+
+    /**
+     * <p>The name of the subnet group.</p>
+     */
+    inline DescribeSubnetGroupsRequest& WithSubnetGroupNames(const Aws::Vector<Aws::String>& value) { SetSubnetGroupNames(value); return *this;}
+
+    /**
+     * <p>The name of the subnet group.</p>
+     */
+    inline DescribeSubnetGroupsRequest& WithSubnetGroupNames(Aws::Vector<Aws::String>&& value) { SetSubnetGroupNames(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the subnet group.</p>
+     */
+    inline DescribeSubnetGroupsRequest& AddSubnetGroupNames(const Aws::String& value) { m_subnetGroupNamesHasBeenSet = true; m_subnetGroupNames.push_back(value); return *this; }
+
+    /**
+     * <p>The name of the subnet group.</p>
+     */
+    inline DescribeSubnetGroupsRequest& AddSubnetGroupNames(Aws::String&& value) { m_subnetGroupNamesHasBeenSet = true; m_subnetGroupNames.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>The name of the subnet group.</p>
+     */
+    inline DescribeSubnetGroupsRequest& AddSubnetGroupNames(const char* value) { m_subnetGroupNamesHasBeenSet = true; m_subnetGroupNames.push_back(value); return *this; }
+
+
+    /**
+     * <p>The maximum number of results to include in the response. If more results
+     * exist than the specified <code>MaxResults</code> value, a token is included in
+     * the response so that the remaining results can be retrieved.</p> <p>The value
+     * for <code>MaxResults</code> must be between 20 and 100.</p>
+     */
+    inline int GetMaxResults() const{ return m_maxResults; }
+
+    /**
+     * <p>The maximum number of results to include in the response. If more results
+     * exist than the specified <code>MaxResults</code> value, a token is included in
+     * the response so that the remaining results can be retrieved.</p> <p>The value
+     * for <code>MaxResults</code> must be between 20 and 100.</p>
+     */
+    inline bool MaxResultsHasBeenSet() const { return m_maxResultsHasBeenSet; }
+
+    /**
+     * <p>The maximum number of results to include in the response. If more results
+     * exist than the specified <code>MaxResults</code> value, a token is included in
+     * the response so that the remaining results can be retrieved.</p> <p>The value
+     * for <code>MaxResults</code> must be between 20 and 100.</p>
+     */
+    inline void SetMaxResults(int value) { m_maxResultsHasBeenSet = true; m_maxResults = value; }
+
+    /**
+     * <p>The maximum number of results to include in the response. If more results
+     * exist than the specified <code>MaxResults</code> value, a token is included in
+     * the response so that the remaining results can be retrieved.</p> <p>The value
+     * for <code>MaxResults</code> must be between 20 and 100.</p>
+     */
+    inline DescribeSubnetGroupsRequest& WithMaxResults(int value) { SetMaxResults(value); return *this;}
+
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline DescribeSubnetGroupsRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline DescribeSubnetGroupsRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token, up to the value specified by
+     * <code>MaxResults</code>.</p>
+     */
+    inline DescribeSubnetGroupsRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+  private:
+
+    Aws::Vector<Aws::String> m_subnetGroupNames;
+    bool m_subnetGroupNamesHasBeenSet;
+
+    int m_maxResults;
+    bool m_maxResultsHasBeenSet;
+
+    Aws::String m_nextToken;
+    bool m_nextTokenHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/DescribeSubnetGroupsResult.h

@@ -0,0 +1,124 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/dax/model/SubnetGroup.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+  class AWS_DAX_API DescribeSubnetGroupsResult
+  {
+  public:
+    DescribeSubnetGroupsResult();
+    DescribeSubnetGroupsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DescribeSubnetGroupsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline DescribeSubnetGroupsResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline DescribeSubnetGroupsResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>Provides an identifier to allow retrieval of paginated results.</p>
+     */
+    inline DescribeSubnetGroupsResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>An array of subnet groups. Each element in the array represents a single
+     * subnet group.</p>
+     */
+    inline const Aws::Vector<SubnetGroup>& GetSubnetGroups() const{ return m_subnetGroups; }
+
+    /**
+     * <p>An array of subnet groups. Each element in the array represents a single
+     * subnet group.</p>
+     */
+    inline void SetSubnetGroups(const Aws::Vector<SubnetGroup>& value) { m_subnetGroups = value; }
+
+    /**
+     * <p>An array of subnet groups. Each element in the array represents a single
+     * subnet group.</p>
+     */
+    inline void SetSubnetGroups(Aws::Vector<SubnetGroup>&& value) { m_subnetGroups = std::move(value); }
+
+    /**
+     * <p>An array of subnet groups. Each element in the array represents a single
+     * subnet group.</p>
+     */
+    inline DescribeSubnetGroupsResult& WithSubnetGroups(const Aws::Vector<SubnetGroup>& value) { SetSubnetGroups(value); return *this;}
+
+    /**
+     * <p>An array of subnet groups. Each element in the array represents a single
+     * subnet group.</p>
+     */
+    inline DescribeSubnetGroupsResult& WithSubnetGroups(Aws::Vector<SubnetGroup>&& value) { SetSubnetGroups(std::move(value)); return *this;}
+
+    /**
+     * <p>An array of subnet groups. Each element in the array represents a single
+     * subnet group.</p>
+     */
+    inline DescribeSubnetGroupsResult& AddSubnetGroups(const SubnetGroup& value) { m_subnetGroups.push_back(value); return *this; }
+
+    /**
+     * <p>An array of subnet groups. Each element in the array represents a single
+     * subnet group.</p>
+     */
+    inline DescribeSubnetGroupsResult& AddSubnetGroups(SubnetGroup&& value) { m_subnetGroups.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_nextToken;
+
+    Aws::Vector<SubnetGroup> m_subnetGroups;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

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

@@ -0,0 +1,114 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents the information required for client programs to connect to the
+   * configuration endpoint for a DAX cluster, or to an individual node within the
+   * cluster.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/Endpoint">AWS API
+   * Reference</a></p>
+   */
+  class AWS_DAX_API Endpoint
+  {
+  public:
+    Endpoint();
+    Endpoint(Aws::Utils::Json::JsonView jsonValue);
+    Endpoint& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The DNS hostname of the endpoint.</p>
+     */
+    inline const Aws::String& GetAddress() const{ return m_address; }
+
+    /**
+     * <p>The DNS hostname of the endpoint.</p>
+     */
+    inline bool AddressHasBeenSet() const { return m_addressHasBeenSet; }
+
+    /**
+     * <p>The DNS hostname of the endpoint.</p>
+     */
+    inline void SetAddress(const Aws::String& value) { m_addressHasBeenSet = true; m_address = value; }
+
+    /**
+     * <p>The DNS hostname of the endpoint.</p>
+     */
+    inline void SetAddress(Aws::String&& value) { m_addressHasBeenSet = true; m_address = std::move(value); }
+
+    /**
+     * <p>The DNS hostname of the endpoint.</p>
+     */
+    inline void SetAddress(const char* value) { m_addressHasBeenSet = true; m_address.assign(value); }
+
+    /**
+     * <p>The DNS hostname of the endpoint.</p>
+     */
+    inline Endpoint& WithAddress(const Aws::String& value) { SetAddress(value); return *this;}
+
+    /**
+     * <p>The DNS hostname of the endpoint.</p>
+     */
+    inline Endpoint& WithAddress(Aws::String&& value) { SetAddress(std::move(value)); return *this;}
+
+    /**
+     * <p>The DNS hostname of the endpoint.</p>
+     */
+    inline Endpoint& WithAddress(const char* value) { SetAddress(value); return *this;}
+
+
+    /**
+     * <p>The port number that applications should use to connect to the endpoint.</p>
+     */
+    inline int GetPort() const{ return m_port; }
+
+    /**
+     * <p>The port number that applications should use to connect to the endpoint.</p>
+     */
+    inline bool PortHasBeenSet() const { return m_portHasBeenSet; }
+
+    /**
+     * <p>The port number that applications should use to connect to the endpoint.</p>
+     */
+    inline void SetPort(int value) { m_portHasBeenSet = true; m_port = value; }
+
+    /**
+     * <p>The port number that applications should use to connect to the endpoint.</p>
+     */
+    inline Endpoint& WithPort(int value) { SetPort(value); return *this;}
+
+  private:
+
+    Aws::String m_address;
+    bool m_addressHasBeenSet;
+
+    int m_port;
+    bool m_portHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/Event.h

@@ -0,0 +1,218 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/dax/model/SourceType.h>
+#include <aws/core/utils/DateTime.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents a single occurrence of something interesting within the system.
+   * Some examples of events are creating a DAX cluster, adding or removing a node,
+   * or rebooting a node.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/Event">AWS API
+   * Reference</a></p>
+   */
+  class AWS_DAX_API Event
+  {
+  public:
+    Event();
+    Event(Aws::Utils::Json::JsonView jsonValue);
+    Event& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The source of the event. For example, if the event occurred at the node
+     * level, the source would be the node ID.</p>
+     */
+    inline const Aws::String& GetSourceName() const{ return m_sourceName; }
+
+    /**
+     * <p>The source of the event. For example, if the event occurred at the node
+     * level, the source would be the node ID.</p>
+     */
+    inline bool SourceNameHasBeenSet() const { return m_sourceNameHasBeenSet; }
+
+    /**
+     * <p>The source of the event. For example, if the event occurred at the node
+     * level, the source would be the node ID.</p>
+     */
+    inline void SetSourceName(const Aws::String& value) { m_sourceNameHasBeenSet = true; m_sourceName = value; }
+
+    /**
+     * <p>The source of the event. For example, if the event occurred at the node
+     * level, the source would be the node ID.</p>
+     */
+    inline void SetSourceName(Aws::String&& value) { m_sourceNameHasBeenSet = true; m_sourceName = std::move(value); }
+
+    /**
+     * <p>The source of the event. For example, if the event occurred at the node
+     * level, the source would be the node ID.</p>
+     */
+    inline void SetSourceName(const char* value) { m_sourceNameHasBeenSet = true; m_sourceName.assign(value); }
+
+    /**
+     * <p>The source of the event. For example, if the event occurred at the node
+     * level, the source would be the node ID.</p>
+     */
+    inline Event& WithSourceName(const Aws::String& value) { SetSourceName(value); return *this;}
+
+    /**
+     * <p>The source of the event. For example, if the event occurred at the node
+     * level, the source would be the node ID.</p>
+     */
+    inline Event& WithSourceName(Aws::String&& value) { SetSourceName(std::move(value)); return *this;}
+
+    /**
+     * <p>The source of the event. For example, if the event occurred at the node
+     * level, the source would be the node ID.</p>
+     */
+    inline Event& WithSourceName(const char* value) { SetSourceName(value); return *this;}
+
+
+    /**
+     * <p>Specifies the origin of this event - a cluster, a parameter group, a node ID,
+     * etc.</p>
+     */
+    inline const SourceType& GetSourceType() const{ return m_sourceType; }
+
+    /**
+     * <p>Specifies the origin of this event - a cluster, a parameter group, a node ID,
+     * etc.</p>
+     */
+    inline bool SourceTypeHasBeenSet() const { return m_sourceTypeHasBeenSet; }
+
+    /**
+     * <p>Specifies the origin of this event - a cluster, a parameter group, a node ID,
+     * etc.</p>
+     */
+    inline void SetSourceType(const SourceType& value) { m_sourceTypeHasBeenSet = true; m_sourceType = value; }
+
+    /**
+     * <p>Specifies the origin of this event - a cluster, a parameter group, a node ID,
+     * etc.</p>
+     */
+    inline void SetSourceType(SourceType&& value) { m_sourceTypeHasBeenSet = true; m_sourceType = std::move(value); }
+
+    /**
+     * <p>Specifies the origin of this event - a cluster, a parameter group, a node ID,
+     * etc.</p>
+     */
+    inline Event& WithSourceType(const SourceType& value) { SetSourceType(value); return *this;}
+
+    /**
+     * <p>Specifies the origin of this event - a cluster, a parameter group, a node ID,
+     * etc.</p>
+     */
+    inline Event& WithSourceType(SourceType&& value) { SetSourceType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>A user-defined message associated with the event.</p>
+     */
+    inline const Aws::String& GetMessage() const{ return m_message; }
+
+    /**
+     * <p>A user-defined message associated with the event.</p>
+     */
+    inline bool MessageHasBeenSet() const { return m_messageHasBeenSet; }
+
+    /**
+     * <p>A user-defined message associated with the event.</p>
+     */
+    inline void SetMessage(const Aws::String& value) { m_messageHasBeenSet = true; m_message = value; }
+
+    /**
+     * <p>A user-defined message associated with the event.</p>
+     */
+    inline void SetMessage(Aws::String&& value) { m_messageHasBeenSet = true; m_message = std::move(value); }
+
+    /**
+     * <p>A user-defined message associated with the event.</p>
+     */
+    inline void SetMessage(const char* value) { m_messageHasBeenSet = true; m_message.assign(value); }
+
+    /**
+     * <p>A user-defined message associated with the event.</p>
+     */
+    inline Event& WithMessage(const Aws::String& value) { SetMessage(value); return *this;}
+
+    /**
+     * <p>A user-defined message associated with the event.</p>
+     */
+    inline Event& WithMessage(Aws::String&& value) { SetMessage(std::move(value)); return *this;}
+
+    /**
+     * <p>A user-defined message associated with the event.</p>
+     */
+    inline Event& WithMessage(const char* value) { SetMessage(value); return *this;}
+
+
+    /**
+     * <p>The date and time when the event occurred.</p>
+     */
+    inline const Aws::Utils::DateTime& GetDate() const{ return m_date; }
+
+    /**
+     * <p>The date and time when the event occurred.</p>
+     */
+    inline bool DateHasBeenSet() const { return m_dateHasBeenSet; }
+
+    /**
+     * <p>The date and time when the event occurred.</p>
+     */
+    inline void SetDate(const Aws::Utils::DateTime& value) { m_dateHasBeenSet = true; m_date = value; }
+
+    /**
+     * <p>The date and time when the event occurred.</p>
+     */
+    inline void SetDate(Aws::Utils::DateTime&& value) { m_dateHasBeenSet = true; m_date = std::move(value); }
+
+    /**
+     * <p>The date and time when the event occurred.</p>
+     */
+    inline Event& WithDate(const Aws::Utils::DateTime& value) { SetDate(value); return *this;}
+
+    /**
+     * <p>The date and time when the event occurred.</p>
+     */
+    inline Event& WithDate(Aws::Utils::DateTime&& value) { SetDate(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_sourceName;
+    bool m_sourceNameHasBeenSet;
+
+    SourceType m_sourceType;
+    bool m_sourceTypeHasBeenSet;
+
+    Aws::String m_message;
+    bool m_messageHasBeenSet;
+
+    Aws::Utils::DateTime m_date;
+    bool m_dateHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/IncreaseReplicationFactorRequest.h

@@ -0,0 +1,177 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/DAXRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DAX_API IncreaseReplicationFactorRequest : public DAXRequest
+  {
+  public:
+    IncreaseReplicationFactorRequest();
+
+    // 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 "IncreaseReplicationFactor"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the DAX cluster that will receive additional nodes.</p>
+     */
+    inline const Aws::String& GetClusterName() const{ return m_clusterName; }
+
+    /**
+     * <p>The name of the DAX cluster that will receive additional nodes.</p>
+     */
+    inline bool ClusterNameHasBeenSet() const { return m_clusterNameHasBeenSet; }
+
+    /**
+     * <p>The name of the DAX cluster that will receive additional nodes.</p>
+     */
+    inline void SetClusterName(const Aws::String& value) { m_clusterNameHasBeenSet = true; m_clusterName = value; }
+
+    /**
+     * <p>The name of the DAX cluster that will receive additional nodes.</p>
+     */
+    inline void SetClusterName(Aws::String&& value) { m_clusterNameHasBeenSet = true; m_clusterName = std::move(value); }
+
+    /**
+     * <p>The name of the DAX cluster that will receive additional nodes.</p>
+     */
+    inline void SetClusterName(const char* value) { m_clusterNameHasBeenSet = true; m_clusterName.assign(value); }
+
+    /**
+     * <p>The name of the DAX cluster that will receive additional nodes.</p>
+     */
+    inline IncreaseReplicationFactorRequest& WithClusterName(const Aws::String& value) { SetClusterName(value); return *this;}
+
+    /**
+     * <p>The name of the DAX cluster that will receive additional nodes.</p>
+     */
+    inline IncreaseReplicationFactorRequest& WithClusterName(Aws::String&& value) { SetClusterName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the DAX cluster that will receive additional nodes.</p>
+     */
+    inline IncreaseReplicationFactorRequest& WithClusterName(const char* value) { SetClusterName(value); return *this;}
+
+
+    /**
+     * <p>The new number of nodes for the DAX cluster.</p>
+     */
+    inline int GetNewReplicationFactor() const{ return m_newReplicationFactor; }
+
+    /**
+     * <p>The new number of nodes for the DAX cluster.</p>
+     */
+    inline bool NewReplicationFactorHasBeenSet() const { return m_newReplicationFactorHasBeenSet; }
+
+    /**
+     * <p>The new number of nodes for the DAX cluster.</p>
+     */
+    inline void SetNewReplicationFactor(int value) { m_newReplicationFactorHasBeenSet = true; m_newReplicationFactor = value; }
+
+    /**
+     * <p>The new number of nodes for the DAX cluster.</p>
+     */
+    inline IncreaseReplicationFactorRequest& WithNewReplicationFactor(int value) { SetNewReplicationFactor(value); return *this;}
+
+
+    /**
+     * <p>The Availability Zones (AZs) in which the cluster nodes will be created. All
+     * nodes belonging to the cluster are placed in these Availability Zones. Use this
+     * parameter if you want to distribute the nodes across multiple AZs.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetAvailabilityZones() const{ return m_availabilityZones; }
+
+    /**
+     * <p>The Availability Zones (AZs) in which the cluster nodes will be created. All
+     * nodes belonging to the cluster are placed in these Availability Zones. Use this
+     * parameter if you want to distribute the nodes across multiple AZs.</p>
+     */
+    inline bool AvailabilityZonesHasBeenSet() const { return m_availabilityZonesHasBeenSet; }
+
+    /**
+     * <p>The Availability Zones (AZs) in which the cluster nodes will be created. All
+     * nodes belonging to the cluster are placed in these Availability Zones. Use this
+     * parameter if you want to distribute the nodes across multiple AZs.</p>
+     */
+    inline void SetAvailabilityZones(const Aws::Vector<Aws::String>& value) { m_availabilityZonesHasBeenSet = true; m_availabilityZones = value; }
+
+    /**
+     * <p>The Availability Zones (AZs) in which the cluster nodes will be created. All
+     * nodes belonging to the cluster are placed in these Availability Zones. Use this
+     * parameter if you want to distribute the nodes across multiple AZs.</p>
+     */
+    inline void SetAvailabilityZones(Aws::Vector<Aws::String>&& value) { m_availabilityZonesHasBeenSet = true; m_availabilityZones = std::move(value); }
+
+    /**
+     * <p>The Availability Zones (AZs) in which the cluster nodes will be created. All
+     * nodes belonging to the cluster are placed in these Availability Zones. Use this
+     * parameter if you want to distribute the nodes across multiple AZs.</p>
+     */
+    inline IncreaseReplicationFactorRequest& WithAvailabilityZones(const Aws::Vector<Aws::String>& value) { SetAvailabilityZones(value); return *this;}
+
+    /**
+     * <p>The Availability Zones (AZs) in which the cluster nodes will be created. All
+     * nodes belonging to the cluster are placed in these Availability Zones. Use this
+     * parameter if you want to distribute the nodes across multiple AZs.</p>
+     */
+    inline IncreaseReplicationFactorRequest& WithAvailabilityZones(Aws::Vector<Aws::String>&& value) { SetAvailabilityZones(std::move(value)); return *this;}
+
+    /**
+     * <p>The Availability Zones (AZs) in which the cluster nodes will be created. All
+     * nodes belonging to the cluster are placed in these Availability Zones. Use this
+     * parameter if you want to distribute the nodes across multiple AZs.</p>
+     */
+    inline IncreaseReplicationFactorRequest& AddAvailabilityZones(const Aws::String& value) { m_availabilityZonesHasBeenSet = true; m_availabilityZones.push_back(value); return *this; }
+
+    /**
+     * <p>The Availability Zones (AZs) in which the cluster nodes will be created. All
+     * nodes belonging to the cluster are placed in these Availability Zones. Use this
+     * parameter if you want to distribute the nodes across multiple AZs.</p>
+     */
+    inline IncreaseReplicationFactorRequest& AddAvailabilityZones(Aws::String&& value) { m_availabilityZonesHasBeenSet = true; m_availabilityZones.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>The Availability Zones (AZs) in which the cluster nodes will be created. All
+     * nodes belonging to the cluster are placed in these Availability Zones. Use this
+     * parameter if you want to distribute the nodes across multiple AZs.</p>
+     */
+    inline IncreaseReplicationFactorRequest& AddAvailabilityZones(const char* value) { m_availabilityZonesHasBeenSet = true; m_availabilityZones.push_back(value); return *this; }
+
+  private:
+
+    Aws::String m_clusterName;
+    bool m_clusterNameHasBeenSet;
+
+    int m_newReplicationFactor;
+    bool m_newReplicationFactorHasBeenSet;
+
+    Aws::Vector<Aws::String> m_availabilityZones;
+    bool m_availabilityZonesHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/IncreaseReplicationFactorResult.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/model/Cluster.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+  class AWS_DAX_API IncreaseReplicationFactorResult
+  {
+  public:
+    IncreaseReplicationFactorResult();
+    IncreaseReplicationFactorResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    IncreaseReplicationFactorResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>A description of the DAX cluster. with its new replication factor.</p>
+     */
+    inline const Cluster& GetCluster() const{ return m_cluster; }
+
+    /**
+     * <p>A description of the DAX cluster. with its new replication factor.</p>
+     */
+    inline void SetCluster(const Cluster& value) { m_cluster = value; }
+
+    /**
+     * <p>A description of the DAX cluster. with its new replication factor.</p>
+     */
+    inline void SetCluster(Cluster&& value) { m_cluster = std::move(value); }
+
+    /**
+     * <p>A description of the DAX cluster. with its new replication factor.</p>
+     */
+    inline IncreaseReplicationFactorResult& WithCluster(const Cluster& value) { SetCluster(value); return *this;}
+
+    /**
+     * <p>A description of the DAX cluster. with its new replication factor.</p>
+     */
+    inline IncreaseReplicationFactorResult& WithCluster(Cluster&& value) { SetCluster(std::move(value)); return *this;}
+
+  private:
+
+    Cluster m_cluster;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/IsModifiable.h

@@ -0,0 +1,32 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace DAX
+{
+namespace Model
+{
+  enum class IsModifiable
+  {
+    NOT_SET,
+    TRUE,
+    FALSE,
+    CONDITIONAL
+  };
+
+namespace IsModifiableMapper
+{
+AWS_DAX_API IsModifiable GetIsModifiableForName(const Aws::String& name);
+
+AWS_DAX_API Aws::String GetNameForIsModifiable(IsModifiable value);
+} // namespace IsModifiableMapper
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/ListTagsRequest.h

@@ -0,0 +1,145 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/DAXRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DAX_API ListTagsRequest : public DAXRequest
+  {
+  public:
+    ListTagsRequest();
+
+    // 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 "ListTags"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the DAX resource to which the tags belong.</p>
+     */
+    inline const Aws::String& GetResourceName() const{ return m_resourceName; }
+
+    /**
+     * <p>The name of the DAX resource to which the tags belong.</p>
+     */
+    inline bool ResourceNameHasBeenSet() const { return m_resourceNameHasBeenSet; }
+
+    /**
+     * <p>The name of the DAX resource to which the tags belong.</p>
+     */
+    inline void SetResourceName(const Aws::String& value) { m_resourceNameHasBeenSet = true; m_resourceName = value; }
+
+    /**
+     * <p>The name of the DAX resource to which the tags belong.</p>
+     */
+    inline void SetResourceName(Aws::String&& value) { m_resourceNameHasBeenSet = true; m_resourceName = std::move(value); }
+
+    /**
+     * <p>The name of the DAX resource to which the tags belong.</p>
+     */
+    inline void SetResourceName(const char* value) { m_resourceNameHasBeenSet = true; m_resourceName.assign(value); }
+
+    /**
+     * <p>The name of the DAX resource to which the tags belong.</p>
+     */
+    inline ListTagsRequest& WithResourceName(const Aws::String& value) { SetResourceName(value); return *this;}
+
+    /**
+     * <p>The name of the DAX resource to which the tags belong.</p>
+     */
+    inline ListTagsRequest& WithResourceName(Aws::String&& value) { SetResourceName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the DAX resource to which the tags belong.</p>
+     */
+    inline ListTagsRequest& WithResourceName(const char* value) { SetResourceName(value); return *this;}
+
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token.</p>
+     */
+    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token.</p>
+     */
+    inline ListTagsRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token.</p>
+     */
+    inline ListTagsRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>An optional token returned from a prior request. Use this token for
+     * pagination of results from this action. If this parameter is specified, the
+     * response includes only results beyond the token.</p>
+     */
+    inline ListTagsRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+  private:
+
+    Aws::String m_resourceName;
+    bool m_resourceNameHasBeenSet;
+
+    Aws::String m_nextToken;
+    bool m_nextTokenHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/ListTagsResult.h

@@ -0,0 +1,131 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/dax/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+  class AWS_DAX_API ListTagsResult
+  {
+  public:
+    ListTagsResult();
+    ListTagsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    ListTagsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>A list of tags currently associated with the DAX cluster.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>A list of tags currently associated with the DAX cluster.</p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tags = value; }
+
+    /**
+     * <p>A list of tags currently associated with the DAX cluster.</p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tags = std::move(value); }
+
+    /**
+     * <p>A list of tags currently associated with the DAX cluster.</p>
+     */
+    inline ListTagsResult& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>A list of tags currently associated with the DAX cluster.</p>
+     */
+    inline ListTagsResult& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of tags currently associated with the DAX cluster.</p>
+     */
+    inline ListTagsResult& AddTags(const Tag& value) { m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>A list of tags currently associated with the DAX cluster.</p>
+     */
+    inline ListTagsResult& AddTags(Tag&& value) { m_tags.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>If this value is present, there are additional results to be displayed. To
+     * retrieve them, call <code>ListTags</code> again, with <code>NextToken</code> set
+     * to this value.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>If this value is present, there are additional results to be displayed. To
+     * retrieve them, call <code>ListTags</code> again, with <code>NextToken</code> set
+     * to this value.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
+
+    /**
+     * <p>If this value is present, there are additional results to be displayed. To
+     * retrieve them, call <code>ListTags</code> again, with <code>NextToken</code> set
+     * to this value.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
+
+    /**
+     * <p>If this value is present, there are additional results to be displayed. To
+     * retrieve them, call <code>ListTags</code> again, with <code>NextToken</code> set
+     * to this value.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
+
+    /**
+     * <p>If this value is present, there are additional results to be displayed. To
+     * retrieve them, call <code>ListTags</code> again, with <code>NextToken</code> set
+     * to this value.</p>
+     */
+    inline ListTagsResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>If this value is present, there are additional results to be displayed. To
+     * retrieve them, call <code>ListTags</code> again, with <code>NextToken</code> set
+     * to this value.</p>
+     */
+    inline ListTagsResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If this value is present, there are additional results to be displayed. To
+     * retrieve them, call <code>ListTags</code> again, with <code>NextToken</code> set
+     * to this value.</p>
+     */
+    inline ListTagsResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+  private:
+
+    Aws::Vector<Tag> m_tags;
+
+    Aws::String m_nextToken;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/Node.h

@@ -0,0 +1,316 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/dax/model/Endpoint.h>
+#include <aws/core/utils/DateTime.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents an individual node within a DAX cluster.</p><p><h3>See Also:</h3> 
+   * <a href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/Node">AWS API
+   * Reference</a></p>
+   */
+  class AWS_DAX_API Node
+  {
+  public:
+    Node();
+    Node(Aws::Utils::Json::JsonView jsonValue);
+    Node& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>A system-generated identifier for the node.</p>
+     */
+    inline const Aws::String& GetNodeId() const{ return m_nodeId; }
+
+    /**
+     * <p>A system-generated identifier for the node.</p>
+     */
+    inline bool NodeIdHasBeenSet() const { return m_nodeIdHasBeenSet; }
+
+    /**
+     * <p>A system-generated identifier for the node.</p>
+     */
+    inline void SetNodeId(const Aws::String& value) { m_nodeIdHasBeenSet = true; m_nodeId = value; }
+
+    /**
+     * <p>A system-generated identifier for the node.</p>
+     */
+    inline void SetNodeId(Aws::String&& value) { m_nodeIdHasBeenSet = true; m_nodeId = std::move(value); }
+
+    /**
+     * <p>A system-generated identifier for the node.</p>
+     */
+    inline void SetNodeId(const char* value) { m_nodeIdHasBeenSet = true; m_nodeId.assign(value); }
+
+    /**
+     * <p>A system-generated identifier for the node.</p>
+     */
+    inline Node& WithNodeId(const Aws::String& value) { SetNodeId(value); return *this;}
+
+    /**
+     * <p>A system-generated identifier for the node.</p>
+     */
+    inline Node& WithNodeId(Aws::String&& value) { SetNodeId(std::move(value)); return *this;}
+
+    /**
+     * <p>A system-generated identifier for the node.</p>
+     */
+    inline Node& WithNodeId(const char* value) { SetNodeId(value); return *this;}
+
+
+    /**
+     * <p>The endpoint for the node, consisting of a DNS name and a port number. Client
+     * applications can connect directly to a node endpoint, if desired (as an
+     * alternative to allowing DAX client software to intelligently route requests and
+     * responses to nodes in the DAX cluster.</p>
+     */
+    inline const Endpoint& GetEndpoint() const{ return m_endpoint; }
+
+    /**
+     * <p>The endpoint for the node, consisting of a DNS name and a port number. Client
+     * applications can connect directly to a node endpoint, if desired (as an
+     * alternative to allowing DAX client software to intelligently route requests and
+     * responses to nodes in the DAX cluster.</p>
+     */
+    inline bool EndpointHasBeenSet() const { return m_endpointHasBeenSet; }
+
+    /**
+     * <p>The endpoint for the node, consisting of a DNS name and a port number. Client
+     * applications can connect directly to a node endpoint, if desired (as an
+     * alternative to allowing DAX client software to intelligently route requests and
+     * responses to nodes in the DAX cluster.</p>
+     */
+    inline void SetEndpoint(const Endpoint& value) { m_endpointHasBeenSet = true; m_endpoint = value; }
+
+    /**
+     * <p>The endpoint for the node, consisting of a DNS name and a port number. Client
+     * applications can connect directly to a node endpoint, if desired (as an
+     * alternative to allowing DAX client software to intelligently route requests and
+     * responses to nodes in the DAX cluster.</p>
+     */
+    inline void SetEndpoint(Endpoint&& value) { m_endpointHasBeenSet = true; m_endpoint = std::move(value); }
+
+    /**
+     * <p>The endpoint for the node, consisting of a DNS name and a port number. Client
+     * applications can connect directly to a node endpoint, if desired (as an
+     * alternative to allowing DAX client software to intelligently route requests and
+     * responses to nodes in the DAX cluster.</p>
+     */
+    inline Node& WithEndpoint(const Endpoint& value) { SetEndpoint(value); return *this;}
+
+    /**
+     * <p>The endpoint for the node, consisting of a DNS name and a port number. Client
+     * applications can connect directly to a node endpoint, if desired (as an
+     * alternative to allowing DAX client software to intelligently route requests and
+     * responses to nodes in the DAX cluster.</p>
+     */
+    inline Node& WithEndpoint(Endpoint&& value) { SetEndpoint(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The date and time (in UNIX epoch format) when the node was launched.</p>
+     */
+    inline const Aws::Utils::DateTime& GetNodeCreateTime() const{ return m_nodeCreateTime; }
+
+    /**
+     * <p>The date and time (in UNIX epoch format) when the node was launched.</p>
+     */
+    inline bool NodeCreateTimeHasBeenSet() const { return m_nodeCreateTimeHasBeenSet; }
+
+    /**
+     * <p>The date and time (in UNIX epoch format) when the node was launched.</p>
+     */
+    inline void SetNodeCreateTime(const Aws::Utils::DateTime& value) { m_nodeCreateTimeHasBeenSet = true; m_nodeCreateTime = value; }
+
+    /**
+     * <p>The date and time (in UNIX epoch format) when the node was launched.</p>
+     */
+    inline void SetNodeCreateTime(Aws::Utils::DateTime&& value) { m_nodeCreateTimeHasBeenSet = true; m_nodeCreateTime = std::move(value); }
+
+    /**
+     * <p>The date and time (in UNIX epoch format) when the node was launched.</p>
+     */
+    inline Node& WithNodeCreateTime(const Aws::Utils::DateTime& value) { SetNodeCreateTime(value); return *this;}
+
+    /**
+     * <p>The date and time (in UNIX epoch format) when the node was launched.</p>
+     */
+    inline Node& WithNodeCreateTime(Aws::Utils::DateTime&& value) { SetNodeCreateTime(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The Availability Zone (AZ) in which the node has been deployed.</p>
+     */
+    inline const Aws::String& GetAvailabilityZone() const{ return m_availabilityZone; }
+
+    /**
+     * <p>The Availability Zone (AZ) in which the node has been deployed.</p>
+     */
+    inline bool AvailabilityZoneHasBeenSet() const { return m_availabilityZoneHasBeenSet; }
+
+    /**
+     * <p>The Availability Zone (AZ) in which the node has been deployed.</p>
+     */
+    inline void SetAvailabilityZone(const Aws::String& value) { m_availabilityZoneHasBeenSet = true; m_availabilityZone = value; }
+
+    /**
+     * <p>The Availability Zone (AZ) in which the node has been deployed.</p>
+     */
+    inline void SetAvailabilityZone(Aws::String&& value) { m_availabilityZoneHasBeenSet = true; m_availabilityZone = std::move(value); }
+
+    /**
+     * <p>The Availability Zone (AZ) in which the node has been deployed.</p>
+     */
+    inline void SetAvailabilityZone(const char* value) { m_availabilityZoneHasBeenSet = true; m_availabilityZone.assign(value); }
+
+    /**
+     * <p>The Availability Zone (AZ) in which the node has been deployed.</p>
+     */
+    inline Node& WithAvailabilityZone(const Aws::String& value) { SetAvailabilityZone(value); return *this;}
+
+    /**
+     * <p>The Availability Zone (AZ) in which the node has been deployed.</p>
+     */
+    inline Node& WithAvailabilityZone(Aws::String&& value) { SetAvailabilityZone(std::move(value)); return *this;}
+
+    /**
+     * <p>The Availability Zone (AZ) in which the node has been deployed.</p>
+     */
+    inline Node& WithAvailabilityZone(const char* value) { SetAvailabilityZone(value); return *this;}
+
+
+    /**
+     * <p>The current status of the node. For example: <code>available</code>.</p>
+     */
+    inline const Aws::String& GetNodeStatus() const{ return m_nodeStatus; }
+
+    /**
+     * <p>The current status of the node. For example: <code>available</code>.</p>
+     */
+    inline bool NodeStatusHasBeenSet() const { return m_nodeStatusHasBeenSet; }
+
+    /**
+     * <p>The current status of the node. For example: <code>available</code>.</p>
+     */
+    inline void SetNodeStatus(const Aws::String& value) { m_nodeStatusHasBeenSet = true; m_nodeStatus = value; }
+
+    /**
+     * <p>The current status of the node. For example: <code>available</code>.</p>
+     */
+    inline void SetNodeStatus(Aws::String&& value) { m_nodeStatusHasBeenSet = true; m_nodeStatus = std::move(value); }
+
+    /**
+     * <p>The current status of the node. For example: <code>available</code>.</p>
+     */
+    inline void SetNodeStatus(const char* value) { m_nodeStatusHasBeenSet = true; m_nodeStatus.assign(value); }
+
+    /**
+     * <p>The current status of the node. For example: <code>available</code>.</p>
+     */
+    inline Node& WithNodeStatus(const Aws::String& value) { SetNodeStatus(value); return *this;}
+
+    /**
+     * <p>The current status of the node. For example: <code>available</code>.</p>
+     */
+    inline Node& WithNodeStatus(Aws::String&& value) { SetNodeStatus(std::move(value)); return *this;}
+
+    /**
+     * <p>The current status of the node. For example: <code>available</code>.</p>
+     */
+    inline Node& WithNodeStatus(const char* value) { SetNodeStatus(value); return *this;}
+
+
+    /**
+     * <p>The status of the parameter group associated with this node. For example,
+     * <code>in-sync</code>.</p>
+     */
+    inline const Aws::String& GetParameterGroupStatus() const{ return m_parameterGroupStatus; }
+
+    /**
+     * <p>The status of the parameter group associated with this node. For example,
+     * <code>in-sync</code>.</p>
+     */
+    inline bool ParameterGroupStatusHasBeenSet() const { return m_parameterGroupStatusHasBeenSet; }
+
+    /**
+     * <p>The status of the parameter group associated with this node. For example,
+     * <code>in-sync</code>.</p>
+     */
+    inline void SetParameterGroupStatus(const Aws::String& value) { m_parameterGroupStatusHasBeenSet = true; m_parameterGroupStatus = value; }
+
+    /**
+     * <p>The status of the parameter group associated with this node. For example,
+     * <code>in-sync</code>.</p>
+     */
+    inline void SetParameterGroupStatus(Aws::String&& value) { m_parameterGroupStatusHasBeenSet = true; m_parameterGroupStatus = std::move(value); }
+
+    /**
+     * <p>The status of the parameter group associated with this node. For example,
+     * <code>in-sync</code>.</p>
+     */
+    inline void SetParameterGroupStatus(const char* value) { m_parameterGroupStatusHasBeenSet = true; m_parameterGroupStatus.assign(value); }
+
+    /**
+     * <p>The status of the parameter group associated with this node. For example,
+     * <code>in-sync</code>.</p>
+     */
+    inline Node& WithParameterGroupStatus(const Aws::String& value) { SetParameterGroupStatus(value); return *this;}
+
+    /**
+     * <p>The status of the parameter group associated with this node. For example,
+     * <code>in-sync</code>.</p>
+     */
+    inline Node& WithParameterGroupStatus(Aws::String&& value) { SetParameterGroupStatus(std::move(value)); return *this;}
+
+    /**
+     * <p>The status of the parameter group associated with this node. For example,
+     * <code>in-sync</code>.</p>
+     */
+    inline Node& WithParameterGroupStatus(const char* value) { SetParameterGroupStatus(value); return *this;}
+
+  private:
+
+    Aws::String m_nodeId;
+    bool m_nodeIdHasBeenSet;
+
+    Endpoint m_endpoint;
+    bool m_endpointHasBeenSet;
+
+    Aws::Utils::DateTime m_nodeCreateTime;
+    bool m_nodeCreateTimeHasBeenSet;
+
+    Aws::String m_availabilityZone;
+    bool m_availabilityZoneHasBeenSet;
+
+    Aws::String m_nodeStatus;
+    bool m_nodeStatusHasBeenSet;
+
+    Aws::String m_parameterGroupStatus;
+    bool m_parameterGroupStatusHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/NodeTypeSpecificValue.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/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents a parameter value that is applicable to a particular node
+   * type.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/NodeTypeSpecificValue">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DAX_API NodeTypeSpecificValue
+  {
+  public:
+    NodeTypeSpecificValue();
+    NodeTypeSpecificValue(Aws::Utils::Json::JsonView jsonValue);
+    NodeTypeSpecificValue& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>A node type to which the parameter value applies.</p>
+     */
+    inline const Aws::String& GetNodeType() const{ return m_nodeType; }
+
+    /**
+     * <p>A node type to which the parameter value applies.</p>
+     */
+    inline bool NodeTypeHasBeenSet() const { return m_nodeTypeHasBeenSet; }
+
+    /**
+     * <p>A node type to which the parameter value applies.</p>
+     */
+    inline void SetNodeType(const Aws::String& value) { m_nodeTypeHasBeenSet = true; m_nodeType = value; }
+
+    /**
+     * <p>A node type to which the parameter value applies.</p>
+     */
+    inline void SetNodeType(Aws::String&& value) { m_nodeTypeHasBeenSet = true; m_nodeType = std::move(value); }
+
+    /**
+     * <p>A node type to which the parameter value applies.</p>
+     */
+    inline void SetNodeType(const char* value) { m_nodeTypeHasBeenSet = true; m_nodeType.assign(value); }
+
+    /**
+     * <p>A node type to which the parameter value applies.</p>
+     */
+    inline NodeTypeSpecificValue& WithNodeType(const Aws::String& value) { SetNodeType(value); return *this;}
+
+    /**
+     * <p>A node type to which the parameter value applies.</p>
+     */
+    inline NodeTypeSpecificValue& WithNodeType(Aws::String&& value) { SetNodeType(std::move(value)); return *this;}
+
+    /**
+     * <p>A node type to which the parameter value applies.</p>
+     */
+    inline NodeTypeSpecificValue& WithNodeType(const char* value) { SetNodeType(value); return *this;}
+
+
+    /**
+     * <p>The parameter value for this node type.</p>
+     */
+    inline const Aws::String& GetValue() const{ return m_value; }
+
+    /**
+     * <p>The parameter value for this node type.</p>
+     */
+    inline bool ValueHasBeenSet() const { return m_valueHasBeenSet; }
+
+    /**
+     * <p>The parameter value for this node type.</p>
+     */
+    inline void SetValue(const Aws::String& value) { m_valueHasBeenSet = true; m_value = value; }
+
+    /**
+     * <p>The parameter value for this node type.</p>
+     */
+    inline void SetValue(Aws::String&& value) { m_valueHasBeenSet = true; m_value = std::move(value); }
+
+    /**
+     * <p>The parameter value for this node type.</p>
+     */
+    inline void SetValue(const char* value) { m_valueHasBeenSet = true; m_value.assign(value); }
+
+    /**
+     * <p>The parameter value for this node type.</p>
+     */
+    inline NodeTypeSpecificValue& WithValue(const Aws::String& value) { SetValue(value); return *this;}
+
+    /**
+     * <p>The parameter value for this node type.</p>
+     */
+    inline NodeTypeSpecificValue& WithValue(Aws::String&& value) { SetValue(std::move(value)); return *this;}
+
+    /**
+     * <p>The parameter value for this node type.</p>
+     */
+    inline NodeTypeSpecificValue& WithValue(const char* value) { SetValue(value); return *this;}
+
+  private:
+
+    Aws::String m_nodeType;
+    bool m_nodeTypeHasBeenSet;
+
+    Aws::String m_value;
+    bool m_valueHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/NotificationConfiguration.h

@@ -0,0 +1,134 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   * <p>Describes a notification topic and its status. Notification topics are used
+   * for publishing DAX events to subscribers using Amazon Simple Notification
+   * Service (SNS).</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/NotificationConfiguration">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DAX_API NotificationConfiguration
+  {
+  public:
+    NotificationConfiguration();
+    NotificationConfiguration(Aws::Utils::Json::JsonView jsonValue);
+    NotificationConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that identifies the topic. </p>
+     */
+    inline const Aws::String& GetTopicArn() const{ return m_topicArn; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that identifies the topic. </p>
+     */
+    inline bool TopicArnHasBeenSet() const { return m_topicArnHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that identifies the topic. </p>
+     */
+    inline void SetTopicArn(const Aws::String& value) { m_topicArnHasBeenSet = true; m_topicArn = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that identifies the topic. </p>
+     */
+    inline void SetTopicArn(Aws::String&& value) { m_topicArnHasBeenSet = true; m_topicArn = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that identifies the topic. </p>
+     */
+    inline void SetTopicArn(const char* value) { m_topicArnHasBeenSet = true; m_topicArn.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that identifies the topic. </p>
+     */
+    inline NotificationConfiguration& WithTopicArn(const Aws::String& value) { SetTopicArn(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that identifies the topic. </p>
+     */
+    inline NotificationConfiguration& WithTopicArn(Aws::String&& value) { SetTopicArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that identifies the topic. </p>
+     */
+    inline NotificationConfiguration& WithTopicArn(const char* value) { SetTopicArn(value); return *this;}
+
+
+    /**
+     * <p>The current state of the topic.</p>
+     */
+    inline const Aws::String& GetTopicStatus() const{ return m_topicStatus; }
+
+    /**
+     * <p>The current state of the topic.</p>
+     */
+    inline bool TopicStatusHasBeenSet() const { return m_topicStatusHasBeenSet; }
+
+    /**
+     * <p>The current state of the topic.</p>
+     */
+    inline void SetTopicStatus(const Aws::String& value) { m_topicStatusHasBeenSet = true; m_topicStatus = value; }
+
+    /**
+     * <p>The current state of the topic.</p>
+     */
+    inline void SetTopicStatus(Aws::String&& value) { m_topicStatusHasBeenSet = true; m_topicStatus = std::move(value); }
+
+    /**
+     * <p>The current state of the topic.</p>
+     */
+    inline void SetTopicStatus(const char* value) { m_topicStatusHasBeenSet = true; m_topicStatus.assign(value); }
+
+    /**
+     * <p>The current state of the topic.</p>
+     */
+    inline NotificationConfiguration& WithTopicStatus(const Aws::String& value) { SetTopicStatus(value); return *this;}
+
+    /**
+     * <p>The current state of the topic.</p>
+     */
+    inline NotificationConfiguration& WithTopicStatus(Aws::String&& value) { SetTopicStatus(std::move(value)); return *this;}
+
+    /**
+     * <p>The current state of the topic.</p>
+     */
+    inline NotificationConfiguration& WithTopicStatus(const char* value) { SetTopicStatus(value); return *this;}
+
+  private:
+
+    Aws::String m_topicArn;
+    bool m_topicArnHasBeenSet;
+
+    Aws::String m_topicStatus;
+    bool m_topicStatusHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/Parameter.h

@@ -0,0 +1,486 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/dax/model/ParameterType.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/dax/model/IsModifiable.h>
+#include <aws/dax/model/ChangeType.h>
+#include <aws/dax/model/NodeTypeSpecificValue.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   * <p>Describes an individual setting that controls some aspect of DAX
+   * behavior.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/Parameter">AWS API
+   * Reference</a></p>
+   */
+  class AWS_DAX_API Parameter
+  {
+  public:
+    Parameter();
+    Parameter(Aws::Utils::Json::JsonView jsonValue);
+    Parameter& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The name of the parameter.</p>
+     */
+    inline const Aws::String& GetParameterName() const{ return m_parameterName; }
+
+    /**
+     * <p>The name of the parameter.</p>
+     */
+    inline bool ParameterNameHasBeenSet() const { return m_parameterNameHasBeenSet; }
+
+    /**
+     * <p>The name of the parameter.</p>
+     */
+    inline void SetParameterName(const Aws::String& value) { m_parameterNameHasBeenSet = true; m_parameterName = value; }
+
+    /**
+     * <p>The name of the parameter.</p>
+     */
+    inline void SetParameterName(Aws::String&& value) { m_parameterNameHasBeenSet = true; m_parameterName = std::move(value); }
+
+    /**
+     * <p>The name of the parameter.</p>
+     */
+    inline void SetParameterName(const char* value) { m_parameterNameHasBeenSet = true; m_parameterName.assign(value); }
+
+    /**
+     * <p>The name of the parameter.</p>
+     */
+    inline Parameter& WithParameterName(const Aws::String& value) { SetParameterName(value); return *this;}
+
+    /**
+     * <p>The name of the parameter.</p>
+     */
+    inline Parameter& WithParameterName(Aws::String&& value) { SetParameterName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the parameter.</p>
+     */
+    inline Parameter& WithParameterName(const char* value) { SetParameterName(value); return *this;}
+
+
+    /**
+     * <p>Determines whether the parameter can be applied to any nodes, or only nodes
+     * of a particular type.</p>
+     */
+    inline const ParameterType& GetParameterType() const{ return m_parameterType; }
+
+    /**
+     * <p>Determines whether the parameter can be applied to any nodes, or only nodes
+     * of a particular type.</p>
+     */
+    inline bool ParameterTypeHasBeenSet() const { return m_parameterTypeHasBeenSet; }
+
+    /**
+     * <p>Determines whether the parameter can be applied to any nodes, or only nodes
+     * of a particular type.</p>
+     */
+    inline void SetParameterType(const ParameterType& value) { m_parameterTypeHasBeenSet = true; m_parameterType = value; }
+
+    /**
+     * <p>Determines whether the parameter can be applied to any nodes, or only nodes
+     * of a particular type.</p>
+     */
+    inline void SetParameterType(ParameterType&& value) { m_parameterTypeHasBeenSet = true; m_parameterType = std::move(value); }
+
+    /**
+     * <p>Determines whether the parameter can be applied to any nodes, or only nodes
+     * of a particular type.</p>
+     */
+    inline Parameter& WithParameterType(const ParameterType& value) { SetParameterType(value); return *this;}
+
+    /**
+     * <p>Determines whether the parameter can be applied to any nodes, or only nodes
+     * of a particular type.</p>
+     */
+    inline Parameter& WithParameterType(ParameterType&& value) { SetParameterType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The value for the parameter.</p>
+     */
+    inline const Aws::String& GetParameterValue() const{ return m_parameterValue; }
+
+    /**
+     * <p>The value for the parameter.</p>
+     */
+    inline bool ParameterValueHasBeenSet() const { return m_parameterValueHasBeenSet; }
+
+    /**
+     * <p>The value for the parameter.</p>
+     */
+    inline void SetParameterValue(const Aws::String& value) { m_parameterValueHasBeenSet = true; m_parameterValue = value; }
+
+    /**
+     * <p>The value for the parameter.</p>
+     */
+    inline void SetParameterValue(Aws::String&& value) { m_parameterValueHasBeenSet = true; m_parameterValue = std::move(value); }
+
+    /**
+     * <p>The value for the parameter.</p>
+     */
+    inline void SetParameterValue(const char* value) { m_parameterValueHasBeenSet = true; m_parameterValue.assign(value); }
+
+    /**
+     * <p>The value for the parameter.</p>
+     */
+    inline Parameter& WithParameterValue(const Aws::String& value) { SetParameterValue(value); return *this;}
+
+    /**
+     * <p>The value for the parameter.</p>
+     */
+    inline Parameter& WithParameterValue(Aws::String&& value) { SetParameterValue(std::move(value)); return *this;}
+
+    /**
+     * <p>The value for the parameter.</p>
+     */
+    inline Parameter& WithParameterValue(const char* value) { SetParameterValue(value); return *this;}
+
+
+    /**
+     * <p>A list of node types, and specific parameter values for each node.</p>
+     */
+    inline const Aws::Vector<NodeTypeSpecificValue>& GetNodeTypeSpecificValues() const{ return m_nodeTypeSpecificValues; }
+
+    /**
+     * <p>A list of node types, and specific parameter values for each node.</p>
+     */
+    inline bool NodeTypeSpecificValuesHasBeenSet() const { return m_nodeTypeSpecificValuesHasBeenSet; }
+
+    /**
+     * <p>A list of node types, and specific parameter values for each node.</p>
+     */
+    inline void SetNodeTypeSpecificValues(const Aws::Vector<NodeTypeSpecificValue>& value) { m_nodeTypeSpecificValuesHasBeenSet = true; m_nodeTypeSpecificValues = value; }
+
+    /**
+     * <p>A list of node types, and specific parameter values for each node.</p>
+     */
+    inline void SetNodeTypeSpecificValues(Aws::Vector<NodeTypeSpecificValue>&& value) { m_nodeTypeSpecificValuesHasBeenSet = true; m_nodeTypeSpecificValues = std::move(value); }
+
+    /**
+     * <p>A list of node types, and specific parameter values for each node.</p>
+     */
+    inline Parameter& WithNodeTypeSpecificValues(const Aws::Vector<NodeTypeSpecificValue>& value) { SetNodeTypeSpecificValues(value); return *this;}
+
+    /**
+     * <p>A list of node types, and specific parameter values for each node.</p>
+     */
+    inline Parameter& WithNodeTypeSpecificValues(Aws::Vector<NodeTypeSpecificValue>&& value) { SetNodeTypeSpecificValues(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of node types, and specific parameter values for each node.</p>
+     */
+    inline Parameter& AddNodeTypeSpecificValues(const NodeTypeSpecificValue& value) { m_nodeTypeSpecificValuesHasBeenSet = true; m_nodeTypeSpecificValues.push_back(value); return *this; }
+
+    /**
+     * <p>A list of node types, and specific parameter values for each node.</p>
+     */
+    inline Parameter& AddNodeTypeSpecificValues(NodeTypeSpecificValue&& value) { m_nodeTypeSpecificValuesHasBeenSet = true; m_nodeTypeSpecificValues.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>A description of the parameter</p>
+     */
+    inline const Aws::String& GetDescription() const{ return m_description; }
+
+    /**
+     * <p>A description of the parameter</p>
+     */
+    inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
+
+    /**
+     * <p>A description of the parameter</p>
+     */
+    inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
+
+    /**
+     * <p>A description of the parameter</p>
+     */
+    inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
+
+    /**
+     * <p>A description of the parameter</p>
+     */
+    inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
+
+    /**
+     * <p>A description of the parameter</p>
+     */
+    inline Parameter& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
+
+    /**
+     * <p>A description of the parameter</p>
+     */
+    inline Parameter& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
+
+    /**
+     * <p>A description of the parameter</p>
+     */
+    inline Parameter& WithDescription(const char* value) { SetDescription(value); return *this;}
+
+
+    /**
+     * <p>How the parameter is defined. For example, <code>system</code> denotes a
+     * system-defined parameter.</p>
+     */
+    inline const Aws::String& GetSource() const{ return m_source; }
+
+    /**
+     * <p>How the parameter is defined. For example, <code>system</code> denotes a
+     * system-defined parameter.</p>
+     */
+    inline bool SourceHasBeenSet() const { return m_sourceHasBeenSet; }
+
+    /**
+     * <p>How the parameter is defined. For example, <code>system</code> denotes a
+     * system-defined parameter.</p>
+     */
+    inline void SetSource(const Aws::String& value) { m_sourceHasBeenSet = true; m_source = value; }
+
+    /**
+     * <p>How the parameter is defined. For example, <code>system</code> denotes a
+     * system-defined parameter.</p>
+     */
+    inline void SetSource(Aws::String&& value) { m_sourceHasBeenSet = true; m_source = std::move(value); }
+
+    /**
+     * <p>How the parameter is defined. For example, <code>system</code> denotes a
+     * system-defined parameter.</p>
+     */
+    inline void SetSource(const char* value) { m_sourceHasBeenSet = true; m_source.assign(value); }
+
+    /**
+     * <p>How the parameter is defined. For example, <code>system</code> denotes a
+     * system-defined parameter.</p>
+     */
+    inline Parameter& WithSource(const Aws::String& value) { SetSource(value); return *this;}
+
+    /**
+     * <p>How the parameter is defined. For example, <code>system</code> denotes a
+     * system-defined parameter.</p>
+     */
+    inline Parameter& WithSource(Aws::String&& value) { SetSource(std::move(value)); return *this;}
+
+    /**
+     * <p>How the parameter is defined. For example, <code>system</code> denotes a
+     * system-defined parameter.</p>
+     */
+    inline Parameter& WithSource(const char* value) { SetSource(value); return *this;}
+
+
+    /**
+     * <p>The data type of the parameter. For example, <code>integer</code>:</p>
+     */
+    inline const Aws::String& GetDataType() const{ return m_dataType; }
+
+    /**
+     * <p>The data type of the parameter. For example, <code>integer</code>:</p>
+     */
+    inline bool DataTypeHasBeenSet() const { return m_dataTypeHasBeenSet; }
+
+    /**
+     * <p>The data type of the parameter. For example, <code>integer</code>:</p>
+     */
+    inline void SetDataType(const Aws::String& value) { m_dataTypeHasBeenSet = true; m_dataType = value; }
+
+    /**
+     * <p>The data type of the parameter. For example, <code>integer</code>:</p>
+     */
+    inline void SetDataType(Aws::String&& value) { m_dataTypeHasBeenSet = true; m_dataType = std::move(value); }
+
+    /**
+     * <p>The data type of the parameter. For example, <code>integer</code>:</p>
+     */
+    inline void SetDataType(const char* value) { m_dataTypeHasBeenSet = true; m_dataType.assign(value); }
+
+    /**
+     * <p>The data type of the parameter. For example, <code>integer</code>:</p>
+     */
+    inline Parameter& WithDataType(const Aws::String& value) { SetDataType(value); return *this;}
+
+    /**
+     * <p>The data type of the parameter. For example, <code>integer</code>:</p>
+     */
+    inline Parameter& WithDataType(Aws::String&& value) { SetDataType(std::move(value)); return *this;}
+
+    /**
+     * <p>The data type of the parameter. For example, <code>integer</code>:</p>
+     */
+    inline Parameter& WithDataType(const char* value) { SetDataType(value); return *this;}
+
+
+    /**
+     * <p>A range of values within which the parameter can be set.</p>
+     */
+    inline const Aws::String& GetAllowedValues() const{ return m_allowedValues; }
+
+    /**
+     * <p>A range of values within which the parameter can be set.</p>
+     */
+    inline bool AllowedValuesHasBeenSet() const { return m_allowedValuesHasBeenSet; }
+
+    /**
+     * <p>A range of values within which the parameter can be set.</p>
+     */
+    inline void SetAllowedValues(const Aws::String& value) { m_allowedValuesHasBeenSet = true; m_allowedValues = value; }
+
+    /**
+     * <p>A range of values within which the parameter can be set.</p>
+     */
+    inline void SetAllowedValues(Aws::String&& value) { m_allowedValuesHasBeenSet = true; m_allowedValues = std::move(value); }
+
+    /**
+     * <p>A range of values within which the parameter can be set.</p>
+     */
+    inline void SetAllowedValues(const char* value) { m_allowedValuesHasBeenSet = true; m_allowedValues.assign(value); }
+
+    /**
+     * <p>A range of values within which the parameter can be set.</p>
+     */
+    inline Parameter& WithAllowedValues(const Aws::String& value) { SetAllowedValues(value); return *this;}
+
+    /**
+     * <p>A range of values within which the parameter can be set.</p>
+     */
+    inline Parameter& WithAllowedValues(Aws::String&& value) { SetAllowedValues(std::move(value)); return *this;}
+
+    /**
+     * <p>A range of values within which the parameter can be set.</p>
+     */
+    inline Parameter& WithAllowedValues(const char* value) { SetAllowedValues(value); return *this;}
+
+
+    /**
+     * <p>Whether the customer is allowed to modify the parameter.</p>
+     */
+    inline const IsModifiable& GetIsModifiable() const{ return m_isModifiable; }
+
+    /**
+     * <p>Whether the customer is allowed to modify the parameter.</p>
+     */
+    inline bool IsModifiableHasBeenSet() const { return m_isModifiableHasBeenSet; }
+
+    /**
+     * <p>Whether the customer is allowed to modify the parameter.</p>
+     */
+    inline void SetIsModifiable(const IsModifiable& value) { m_isModifiableHasBeenSet = true; m_isModifiable = value; }
+
+    /**
+     * <p>Whether the customer is allowed to modify the parameter.</p>
+     */
+    inline void SetIsModifiable(IsModifiable&& value) { m_isModifiableHasBeenSet = true; m_isModifiable = std::move(value); }
+
+    /**
+     * <p>Whether the customer is allowed to modify the parameter.</p>
+     */
+    inline Parameter& WithIsModifiable(const IsModifiable& value) { SetIsModifiable(value); return *this;}
+
+    /**
+     * <p>Whether the customer is allowed to modify the parameter.</p>
+     */
+    inline Parameter& WithIsModifiable(IsModifiable&& value) { SetIsModifiable(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The conditions under which changes to this parameter can be applied. For
+     * example, <code>requires-reboot</code> indicates that a new value for this
+     * parameter will only take effect if a node is rebooted.</p>
+     */
+    inline const ChangeType& GetChangeType() const{ return m_changeType; }
+
+    /**
+     * <p>The conditions under which changes to this parameter can be applied. For
+     * example, <code>requires-reboot</code> indicates that a new value for this
+     * parameter will only take effect if a node is rebooted.</p>
+     */
+    inline bool ChangeTypeHasBeenSet() const { return m_changeTypeHasBeenSet; }
+
+    /**
+     * <p>The conditions under which changes to this parameter can be applied. For
+     * example, <code>requires-reboot</code> indicates that a new value for this
+     * parameter will only take effect if a node is rebooted.</p>
+     */
+    inline void SetChangeType(const ChangeType& value) { m_changeTypeHasBeenSet = true; m_changeType = value; }
+
+    /**
+     * <p>The conditions under which changes to this parameter can be applied. For
+     * example, <code>requires-reboot</code> indicates that a new value for this
+     * parameter will only take effect if a node is rebooted.</p>
+     */
+    inline void SetChangeType(ChangeType&& value) { m_changeTypeHasBeenSet = true; m_changeType = std::move(value); }
+
+    /**
+     * <p>The conditions under which changes to this parameter can be applied. For
+     * example, <code>requires-reboot</code> indicates that a new value for this
+     * parameter will only take effect if a node is rebooted.</p>
+     */
+    inline Parameter& WithChangeType(const ChangeType& value) { SetChangeType(value); return *this;}
+
+    /**
+     * <p>The conditions under which changes to this parameter can be applied. For
+     * example, <code>requires-reboot</code> indicates that a new value for this
+     * parameter will only take effect if a node is rebooted.</p>
+     */
+    inline Parameter& WithChangeType(ChangeType&& value) { SetChangeType(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_parameterName;
+    bool m_parameterNameHasBeenSet;
+
+    ParameterType m_parameterType;
+    bool m_parameterTypeHasBeenSet;
+
+    Aws::String m_parameterValue;
+    bool m_parameterValueHasBeenSet;
+
+    Aws::Vector<NodeTypeSpecificValue> m_nodeTypeSpecificValues;
+    bool m_nodeTypeSpecificValuesHasBeenSet;
+
+    Aws::String m_description;
+    bool m_descriptionHasBeenSet;
+
+    Aws::String m_source;
+    bool m_sourceHasBeenSet;
+
+    Aws::String m_dataType;
+    bool m_dataTypeHasBeenSet;
+
+    Aws::String m_allowedValues;
+    bool m_allowedValuesHasBeenSet;
+
+    IsModifiable m_isModifiable;
+    bool m_isModifiableHasBeenSet;
+
+    ChangeType m_changeType;
+    bool m_changeTypeHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/ParameterGroup.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/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   * <p>A named set of parameters that are applied to all of the nodes in a DAX
+   * cluster.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/ParameterGroup">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DAX_API ParameterGroup
+  {
+  public:
+    ParameterGroup();
+    ParameterGroup(Aws::Utils::Json::JsonView jsonValue);
+    ParameterGroup& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline const Aws::String& GetParameterGroupName() const{ return m_parameterGroupName; }
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline bool ParameterGroupNameHasBeenSet() const { return m_parameterGroupNameHasBeenSet; }
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline void SetParameterGroupName(const Aws::String& value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName = value; }
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline void SetParameterGroupName(Aws::String&& value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName = std::move(value); }
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline void SetParameterGroupName(const char* value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName.assign(value); }
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline ParameterGroup& WithParameterGroupName(const Aws::String& value) { SetParameterGroupName(value); return *this;}
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline ParameterGroup& WithParameterGroupName(Aws::String&& value) { SetParameterGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline ParameterGroup& WithParameterGroupName(const char* value) { SetParameterGroupName(value); return *this;}
+
+
+    /**
+     * <p>A description of the parameter group.</p>
+     */
+    inline const Aws::String& GetDescription() const{ return m_description; }
+
+    /**
+     * <p>A description of the parameter group.</p>
+     */
+    inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
+
+    /**
+     * <p>A description of the parameter group.</p>
+     */
+    inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
+
+    /**
+     * <p>A description of the parameter group.</p>
+     */
+    inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
+
+    /**
+     * <p>A description of the parameter group.</p>
+     */
+    inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
+
+    /**
+     * <p>A description of the parameter group.</p>
+     */
+    inline ParameterGroup& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
+
+    /**
+     * <p>A description of the parameter group.</p>
+     */
+    inline ParameterGroup& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
+
+    /**
+     * <p>A description of the parameter group.</p>
+     */
+    inline ParameterGroup& WithDescription(const char* value) { SetDescription(value); return *this;}
+
+  private:
+
+    Aws::String m_parameterGroupName;
+    bool m_parameterGroupNameHasBeenSet;
+
+    Aws::String m_description;
+    bool m_descriptionHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/ParameterGroupStatus.h

@@ -0,0 +1,182 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   * <p>The status of a parameter group.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/ParameterGroupStatus">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DAX_API ParameterGroupStatus
+  {
+  public:
+    ParameterGroupStatus();
+    ParameterGroupStatus(Aws::Utils::Json::JsonView jsonValue);
+    ParameterGroupStatus& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline const Aws::String& GetParameterGroupName() const{ return m_parameterGroupName; }
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline bool ParameterGroupNameHasBeenSet() const { return m_parameterGroupNameHasBeenSet; }
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline void SetParameterGroupName(const Aws::String& value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName = value; }
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline void SetParameterGroupName(Aws::String&& value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName = std::move(value); }
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline void SetParameterGroupName(const char* value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName.assign(value); }
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline ParameterGroupStatus& WithParameterGroupName(const Aws::String& value) { SetParameterGroupName(value); return *this;}
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline ParameterGroupStatus& WithParameterGroupName(Aws::String&& value) { SetParameterGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline ParameterGroupStatus& WithParameterGroupName(const char* value) { SetParameterGroupName(value); return *this;}
+
+
+    /**
+     * <p>The status of parameter updates. </p>
+     */
+    inline const Aws::String& GetParameterApplyStatus() const{ return m_parameterApplyStatus; }
+
+    /**
+     * <p>The status of parameter updates. </p>
+     */
+    inline bool ParameterApplyStatusHasBeenSet() const { return m_parameterApplyStatusHasBeenSet; }
+
+    /**
+     * <p>The status of parameter updates. </p>
+     */
+    inline void SetParameterApplyStatus(const Aws::String& value) { m_parameterApplyStatusHasBeenSet = true; m_parameterApplyStatus = value; }
+
+    /**
+     * <p>The status of parameter updates. </p>
+     */
+    inline void SetParameterApplyStatus(Aws::String&& value) { m_parameterApplyStatusHasBeenSet = true; m_parameterApplyStatus = std::move(value); }
+
+    /**
+     * <p>The status of parameter updates. </p>
+     */
+    inline void SetParameterApplyStatus(const char* value) { m_parameterApplyStatusHasBeenSet = true; m_parameterApplyStatus.assign(value); }
+
+    /**
+     * <p>The status of parameter updates. </p>
+     */
+    inline ParameterGroupStatus& WithParameterApplyStatus(const Aws::String& value) { SetParameterApplyStatus(value); return *this;}
+
+    /**
+     * <p>The status of parameter updates. </p>
+     */
+    inline ParameterGroupStatus& WithParameterApplyStatus(Aws::String&& value) { SetParameterApplyStatus(std::move(value)); return *this;}
+
+    /**
+     * <p>The status of parameter updates. </p>
+     */
+    inline ParameterGroupStatus& WithParameterApplyStatus(const char* value) { SetParameterApplyStatus(value); return *this;}
+
+
+    /**
+     * <p>The node IDs of one or more nodes to be rebooted.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetNodeIdsToReboot() const{ return m_nodeIdsToReboot; }
+
+    /**
+     * <p>The node IDs of one or more nodes to be rebooted.</p>
+     */
+    inline bool NodeIdsToRebootHasBeenSet() const { return m_nodeIdsToRebootHasBeenSet; }
+
+    /**
+     * <p>The node IDs of one or more nodes to be rebooted.</p>
+     */
+    inline void SetNodeIdsToReboot(const Aws::Vector<Aws::String>& value) { m_nodeIdsToRebootHasBeenSet = true; m_nodeIdsToReboot = value; }
+
+    /**
+     * <p>The node IDs of one or more nodes to be rebooted.</p>
+     */
+    inline void SetNodeIdsToReboot(Aws::Vector<Aws::String>&& value) { m_nodeIdsToRebootHasBeenSet = true; m_nodeIdsToReboot = std::move(value); }
+
+    /**
+     * <p>The node IDs of one or more nodes to be rebooted.</p>
+     */
+    inline ParameterGroupStatus& WithNodeIdsToReboot(const Aws::Vector<Aws::String>& value) { SetNodeIdsToReboot(value); return *this;}
+
+    /**
+     * <p>The node IDs of one or more nodes to be rebooted.</p>
+     */
+    inline ParameterGroupStatus& WithNodeIdsToReboot(Aws::Vector<Aws::String>&& value) { SetNodeIdsToReboot(std::move(value)); return *this;}
+
+    /**
+     * <p>The node IDs of one or more nodes to be rebooted.</p>
+     */
+    inline ParameterGroupStatus& AddNodeIdsToReboot(const Aws::String& value) { m_nodeIdsToRebootHasBeenSet = true; m_nodeIdsToReboot.push_back(value); return *this; }
+
+    /**
+     * <p>The node IDs of one or more nodes to be rebooted.</p>
+     */
+    inline ParameterGroupStatus& AddNodeIdsToReboot(Aws::String&& value) { m_nodeIdsToRebootHasBeenSet = true; m_nodeIdsToReboot.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>The node IDs of one or more nodes to be rebooted.</p>
+     */
+    inline ParameterGroupStatus& AddNodeIdsToReboot(const char* value) { m_nodeIdsToRebootHasBeenSet = true; m_nodeIdsToReboot.push_back(value); return *this; }
+
+  private:
+
+    Aws::String m_parameterGroupName;
+    bool m_parameterGroupNameHasBeenSet;
+
+    Aws::String m_parameterApplyStatus;
+    bool m_parameterApplyStatusHasBeenSet;
+
+    Aws::Vector<Aws::String> m_nodeIdsToReboot;
+    bool m_nodeIdsToRebootHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/ParameterNameValue.h

@@ -0,0 +1,132 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   * <p>An individual DAX parameter.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/ParameterNameValue">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DAX_API ParameterNameValue
+  {
+  public:
+    ParameterNameValue();
+    ParameterNameValue(Aws::Utils::Json::JsonView jsonValue);
+    ParameterNameValue& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The name of the parameter.</p>
+     */
+    inline const Aws::String& GetParameterName() const{ return m_parameterName; }
+
+    /**
+     * <p>The name of the parameter.</p>
+     */
+    inline bool ParameterNameHasBeenSet() const { return m_parameterNameHasBeenSet; }
+
+    /**
+     * <p>The name of the parameter.</p>
+     */
+    inline void SetParameterName(const Aws::String& value) { m_parameterNameHasBeenSet = true; m_parameterName = value; }
+
+    /**
+     * <p>The name of the parameter.</p>
+     */
+    inline void SetParameterName(Aws::String&& value) { m_parameterNameHasBeenSet = true; m_parameterName = std::move(value); }
+
+    /**
+     * <p>The name of the parameter.</p>
+     */
+    inline void SetParameterName(const char* value) { m_parameterNameHasBeenSet = true; m_parameterName.assign(value); }
+
+    /**
+     * <p>The name of the parameter.</p>
+     */
+    inline ParameterNameValue& WithParameterName(const Aws::String& value) { SetParameterName(value); return *this;}
+
+    /**
+     * <p>The name of the parameter.</p>
+     */
+    inline ParameterNameValue& WithParameterName(Aws::String&& value) { SetParameterName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the parameter.</p>
+     */
+    inline ParameterNameValue& WithParameterName(const char* value) { SetParameterName(value); return *this;}
+
+
+    /**
+     * <p>The value of the parameter.</p>
+     */
+    inline const Aws::String& GetParameterValue() const{ return m_parameterValue; }
+
+    /**
+     * <p>The value of the parameter.</p>
+     */
+    inline bool ParameterValueHasBeenSet() const { return m_parameterValueHasBeenSet; }
+
+    /**
+     * <p>The value of the parameter.</p>
+     */
+    inline void SetParameterValue(const Aws::String& value) { m_parameterValueHasBeenSet = true; m_parameterValue = value; }
+
+    /**
+     * <p>The value of the parameter.</p>
+     */
+    inline void SetParameterValue(Aws::String&& value) { m_parameterValueHasBeenSet = true; m_parameterValue = std::move(value); }
+
+    /**
+     * <p>The value of the parameter.</p>
+     */
+    inline void SetParameterValue(const char* value) { m_parameterValueHasBeenSet = true; m_parameterValue.assign(value); }
+
+    /**
+     * <p>The value of the parameter.</p>
+     */
+    inline ParameterNameValue& WithParameterValue(const Aws::String& value) { SetParameterValue(value); return *this;}
+
+    /**
+     * <p>The value of the parameter.</p>
+     */
+    inline ParameterNameValue& WithParameterValue(Aws::String&& value) { SetParameterValue(std::move(value)); return *this;}
+
+    /**
+     * <p>The value of the parameter.</p>
+     */
+    inline ParameterNameValue& WithParameterValue(const char* value) { SetParameterValue(value); return *this;}
+
+  private:
+
+    Aws::String m_parameterName;
+    bool m_parameterNameHasBeenSet;
+
+    Aws::String m_parameterValue;
+    bool m_parameterValueHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/ParameterType.h

@@ -0,0 +1,31 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace DAX
+{
+namespace Model
+{
+  enum class ParameterType
+  {
+    NOT_SET,
+    DEFAULT,
+    NODE_TYPE_SPECIFIC
+  };
+
+namespace ParameterTypeMapper
+{
+AWS_DAX_API ParameterType GetParameterTypeForName(const Aws::String& name);
+
+AWS_DAX_API Aws::String GetNameForParameterType(ParameterType value);
+} // namespace ParameterTypeMapper
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/RebootNodeRequest.h

@@ -0,0 +1,129 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/DAXRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DAX_API RebootNodeRequest : public DAXRequest
+  {
+  public:
+    RebootNodeRequest();
+
+    // 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 "RebootNode"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the DAX cluster containing the node to be rebooted.</p>
+     */
+    inline const Aws::String& GetClusterName() const{ return m_clusterName; }
+
+    /**
+     * <p>The name of the DAX cluster containing the node to be rebooted.</p>
+     */
+    inline bool ClusterNameHasBeenSet() const { return m_clusterNameHasBeenSet; }
+
+    /**
+     * <p>The name of the DAX cluster containing the node to be rebooted.</p>
+     */
+    inline void SetClusterName(const Aws::String& value) { m_clusterNameHasBeenSet = true; m_clusterName = value; }
+
+    /**
+     * <p>The name of the DAX cluster containing the node to be rebooted.</p>
+     */
+    inline void SetClusterName(Aws::String&& value) { m_clusterNameHasBeenSet = true; m_clusterName = std::move(value); }
+
+    /**
+     * <p>The name of the DAX cluster containing the node to be rebooted.</p>
+     */
+    inline void SetClusterName(const char* value) { m_clusterNameHasBeenSet = true; m_clusterName.assign(value); }
+
+    /**
+     * <p>The name of the DAX cluster containing the node to be rebooted.</p>
+     */
+    inline RebootNodeRequest& WithClusterName(const Aws::String& value) { SetClusterName(value); return *this;}
+
+    /**
+     * <p>The name of the DAX cluster containing the node to be rebooted.</p>
+     */
+    inline RebootNodeRequest& WithClusterName(Aws::String&& value) { SetClusterName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the DAX cluster containing the node to be rebooted.</p>
+     */
+    inline RebootNodeRequest& WithClusterName(const char* value) { SetClusterName(value); return *this;}
+
+
+    /**
+     * <p>The system-assigned ID of the node to be rebooted.</p>
+     */
+    inline const Aws::String& GetNodeId() const{ return m_nodeId; }
+
+    /**
+     * <p>The system-assigned ID of the node to be rebooted.</p>
+     */
+    inline bool NodeIdHasBeenSet() const { return m_nodeIdHasBeenSet; }
+
+    /**
+     * <p>The system-assigned ID of the node to be rebooted.</p>
+     */
+    inline void SetNodeId(const Aws::String& value) { m_nodeIdHasBeenSet = true; m_nodeId = value; }
+
+    /**
+     * <p>The system-assigned ID of the node to be rebooted.</p>
+     */
+    inline void SetNodeId(Aws::String&& value) { m_nodeIdHasBeenSet = true; m_nodeId = std::move(value); }
+
+    /**
+     * <p>The system-assigned ID of the node to be rebooted.</p>
+     */
+    inline void SetNodeId(const char* value) { m_nodeIdHasBeenSet = true; m_nodeId.assign(value); }
+
+    /**
+     * <p>The system-assigned ID of the node to be rebooted.</p>
+     */
+    inline RebootNodeRequest& WithNodeId(const Aws::String& value) { SetNodeId(value); return *this;}
+
+    /**
+     * <p>The system-assigned ID of the node to be rebooted.</p>
+     */
+    inline RebootNodeRequest& WithNodeId(Aws::String&& value) { SetNodeId(std::move(value)); return *this;}
+
+    /**
+     * <p>The system-assigned ID of the node to be rebooted.</p>
+     */
+    inline RebootNodeRequest& WithNodeId(const char* value) { SetNodeId(value); return *this;}
+
+  private:
+
+    Aws::String m_clusterName;
+    bool m_clusterNameHasBeenSet;
+
+    Aws::String m_nodeId;
+    bool m_nodeIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/RebootNodeResult.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/model/Cluster.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+  class AWS_DAX_API RebootNodeResult
+  {
+  public:
+    RebootNodeResult();
+    RebootNodeResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    RebootNodeResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>A description of the DAX cluster after a node has been rebooted.</p>
+     */
+    inline const Cluster& GetCluster() const{ return m_cluster; }
+
+    /**
+     * <p>A description of the DAX cluster after a node has been rebooted.</p>
+     */
+    inline void SetCluster(const Cluster& value) { m_cluster = value; }
+
+    /**
+     * <p>A description of the DAX cluster after a node has been rebooted.</p>
+     */
+    inline void SetCluster(Cluster&& value) { m_cluster = std::move(value); }
+
+    /**
+     * <p>A description of the DAX cluster after a node has been rebooted.</p>
+     */
+    inline RebootNodeResult& WithCluster(const Cluster& value) { SetCluster(value); return *this;}
+
+    /**
+     * <p>A description of the DAX cluster after a node has been rebooted.</p>
+     */
+    inline RebootNodeResult& WithCluster(Cluster&& value) { SetCluster(std::move(value)); return *this;}
+
+  private:
+
+    Cluster m_cluster;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/SSEDescription.h

@@ -0,0 +1,109 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/model/SSEStatus.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   * <p>The description of the server-side encryption status on the specified DAX
+   * cluster.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/SSEDescription">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DAX_API SSEDescription
+  {
+  public:
+    SSEDescription();
+    SSEDescription(Aws::Utils::Json::JsonView jsonValue);
+    SSEDescription& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The current state of server-side encryption:</p> <ul> <li> <p>
+     * <code>ENABLING</code> - Server-side encryption is being enabled.</p> </li> <li>
+     * <p> <code>ENABLED</code> - Server-side encryption is enabled.</p> </li> <li> <p>
+     * <code>DISABLING</code> - Server-side encryption is being disabled.</p> </li>
+     * <li> <p> <code>DISABLED</code> - Server-side encryption is disabled.</p> </li>
+     * </ul>
+     */
+    inline const SSEStatus& GetStatus() const{ return m_status; }
+
+    /**
+     * <p>The current state of server-side encryption:</p> <ul> <li> <p>
+     * <code>ENABLING</code> - Server-side encryption is being enabled.</p> </li> <li>
+     * <p> <code>ENABLED</code> - Server-side encryption is enabled.</p> </li> <li> <p>
+     * <code>DISABLING</code> - Server-side encryption is being disabled.</p> </li>
+     * <li> <p> <code>DISABLED</code> - Server-side encryption is disabled.</p> </li>
+     * </ul>
+     */
+    inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
+
+    /**
+     * <p>The current state of server-side encryption:</p> <ul> <li> <p>
+     * <code>ENABLING</code> - Server-side encryption is being enabled.</p> </li> <li>
+     * <p> <code>ENABLED</code> - Server-side encryption is enabled.</p> </li> <li> <p>
+     * <code>DISABLING</code> - Server-side encryption is being disabled.</p> </li>
+     * <li> <p> <code>DISABLED</code> - Server-side encryption is disabled.</p> </li>
+     * </ul>
+     */
+    inline void SetStatus(const SSEStatus& value) { m_statusHasBeenSet = true; m_status = value; }
+
+    /**
+     * <p>The current state of server-side encryption:</p> <ul> <li> <p>
+     * <code>ENABLING</code> - Server-side encryption is being enabled.</p> </li> <li>
+     * <p> <code>ENABLED</code> - Server-side encryption is enabled.</p> </li> <li> <p>
+     * <code>DISABLING</code> - Server-side encryption is being disabled.</p> </li>
+     * <li> <p> <code>DISABLED</code> - Server-side encryption is disabled.</p> </li>
+     * </ul>
+     */
+    inline void SetStatus(SSEStatus&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }
+
+    /**
+     * <p>The current state of server-side encryption:</p> <ul> <li> <p>
+     * <code>ENABLING</code> - Server-side encryption is being enabled.</p> </li> <li>
+     * <p> <code>ENABLED</code> - Server-side encryption is enabled.</p> </li> <li> <p>
+     * <code>DISABLING</code> - Server-side encryption is being disabled.</p> </li>
+     * <li> <p> <code>DISABLED</code> - Server-side encryption is disabled.</p> </li>
+     * </ul>
+     */
+    inline SSEDescription& WithStatus(const SSEStatus& value) { SetStatus(value); return *this;}
+
+    /**
+     * <p>The current state of server-side encryption:</p> <ul> <li> <p>
+     * <code>ENABLING</code> - Server-side encryption is being enabled.</p> </li> <li>
+     * <p> <code>ENABLED</code> - Server-side encryption is enabled.</p> </li> <li> <p>
+     * <code>DISABLING</code> - Server-side encryption is being disabled.</p> </li>
+     * <li> <p> <code>DISABLED</code> - Server-side encryption is disabled.</p> </li>
+     * </ul>
+     */
+    inline SSEDescription& WithStatus(SSEStatus&& value) { SetStatus(std::move(value)); return *this;}
+
+  private:
+
+    SSEStatus m_status;
+    bool m_statusHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/SSESpecification.h

@@ -0,0 +1,71 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents the settings used to enable server-side encryption.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/SSESpecification">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DAX_API SSESpecification
+  {
+  public:
+    SSESpecification();
+    SSESpecification(Aws::Utils::Json::JsonView jsonValue);
+    SSESpecification& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Indicates whether server-side encryption is enabled (true) or disabled
+     * (false) on the cluster.</p>
+     */
+    inline bool GetEnabled() const{ return m_enabled; }
+
+    /**
+     * <p>Indicates whether server-side encryption is enabled (true) or disabled
+     * (false) on the cluster.</p>
+     */
+    inline bool EnabledHasBeenSet() const { return m_enabledHasBeenSet; }
+
+    /**
+     * <p>Indicates whether server-side encryption is enabled (true) or disabled
+     * (false) on the cluster.</p>
+     */
+    inline void SetEnabled(bool value) { m_enabledHasBeenSet = true; m_enabled = value; }
+
+    /**
+     * <p>Indicates whether server-side encryption is enabled (true) or disabled
+     * (false) on the cluster.</p>
+     */
+    inline SSESpecification& WithEnabled(bool value) { SetEnabled(value); return *this;}
+
+  private:
+
+    bool m_enabled;
+    bool m_enabledHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/SSEStatus.h

@@ -0,0 +1,33 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace DAX
+{
+namespace Model
+{
+  enum class SSEStatus
+  {
+    NOT_SET,
+    ENABLING,
+    ENABLED,
+    DISABLING,
+    DISABLED
+  };
+
+namespace SSEStatusMapper
+{
+AWS_DAX_API SSEStatus GetSSEStatusForName(const Aws::String& name);
+
+AWS_DAX_API Aws::String GetNameForSSEStatus(SSEStatus value);
+} // namespace SSEStatusMapper
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/SecurityGroupMembership.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/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   * <p>An individual VPC security group and its status.</p><p><h3>See Also:</h3>  
+   * <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/SecurityGroupMembership">AWS
+   * API Reference</a></p>
+   */
+  class AWS_DAX_API SecurityGroupMembership
+  {
+  public:
+    SecurityGroupMembership();
+    SecurityGroupMembership(Aws::Utils::Json::JsonView jsonValue);
+    SecurityGroupMembership& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The unique ID for this security group.</p>
+     */
+    inline const Aws::String& GetSecurityGroupIdentifier() const{ return m_securityGroupIdentifier; }
+
+    /**
+     * <p>The unique ID for this security group.</p>
+     */
+    inline bool SecurityGroupIdentifierHasBeenSet() const { return m_securityGroupIdentifierHasBeenSet; }
+
+    /**
+     * <p>The unique ID for this security group.</p>
+     */
+    inline void SetSecurityGroupIdentifier(const Aws::String& value) { m_securityGroupIdentifierHasBeenSet = true; m_securityGroupIdentifier = value; }
+
+    /**
+     * <p>The unique ID for this security group.</p>
+     */
+    inline void SetSecurityGroupIdentifier(Aws::String&& value) { m_securityGroupIdentifierHasBeenSet = true; m_securityGroupIdentifier = std::move(value); }
+
+    /**
+     * <p>The unique ID for this security group.</p>
+     */
+    inline void SetSecurityGroupIdentifier(const char* value) { m_securityGroupIdentifierHasBeenSet = true; m_securityGroupIdentifier.assign(value); }
+
+    /**
+     * <p>The unique ID for this security group.</p>
+     */
+    inline SecurityGroupMembership& WithSecurityGroupIdentifier(const Aws::String& value) { SetSecurityGroupIdentifier(value); return *this;}
+
+    /**
+     * <p>The unique ID for this security group.</p>
+     */
+    inline SecurityGroupMembership& WithSecurityGroupIdentifier(Aws::String&& value) { SetSecurityGroupIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>The unique ID for this security group.</p>
+     */
+    inline SecurityGroupMembership& WithSecurityGroupIdentifier(const char* value) { SetSecurityGroupIdentifier(value); return *this;}
+
+
+    /**
+     * <p>The status of this security group.</p>
+     */
+    inline const Aws::String& GetStatus() const{ return m_status; }
+
+    /**
+     * <p>The status of this security group.</p>
+     */
+    inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
+
+    /**
+     * <p>The status of this security group.</p>
+     */
+    inline void SetStatus(const Aws::String& value) { m_statusHasBeenSet = true; m_status = value; }
+
+    /**
+     * <p>The status of this security group.</p>
+     */
+    inline void SetStatus(Aws::String&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }
+
+    /**
+     * <p>The status of this security group.</p>
+     */
+    inline void SetStatus(const char* value) { m_statusHasBeenSet = true; m_status.assign(value); }
+
+    /**
+     * <p>The status of this security group.</p>
+     */
+    inline SecurityGroupMembership& WithStatus(const Aws::String& value) { SetStatus(value); return *this;}
+
+    /**
+     * <p>The status of this security group.</p>
+     */
+    inline SecurityGroupMembership& WithStatus(Aws::String&& value) { SetStatus(std::move(value)); return *this;}
+
+    /**
+     * <p>The status of this security group.</p>
+     */
+    inline SecurityGroupMembership& WithStatus(const char* value) { SetStatus(value); return *this;}
+
+  private:
+
+    Aws::String m_securityGroupIdentifier;
+    bool m_securityGroupIdentifierHasBeenSet;
+
+    Aws::String m_status;
+    bool m_statusHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/SourceType.h

@@ -0,0 +1,32 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace DAX
+{
+namespace Model
+{
+  enum class SourceType
+  {
+    NOT_SET,
+    CLUSTER,
+    PARAMETER_GROUP,
+    SUBNET_GROUP
+  };
+
+namespace SourceTypeMapper
+{
+AWS_DAX_API SourceType GetSourceTypeForName(const Aws::String& name);
+
+AWS_DAX_API Aws::String GetNameForSourceType(SourceType value);
+} // namespace SourceTypeMapper
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/Subnet.h

@@ -0,0 +1,134 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents the subnet associated with a DAX cluster. This parameter refers to
+   * subnets defined in Amazon Virtual Private Cloud (Amazon VPC) and used with
+   * DAX.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/Subnet">AWS API
+   * Reference</a></p>
+   */
+  class AWS_DAX_API Subnet
+  {
+  public:
+    Subnet();
+    Subnet(Aws::Utils::Json::JsonView jsonValue);
+    Subnet& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The system-assigned identifier for the subnet.</p>
+     */
+    inline const Aws::String& GetSubnetIdentifier() const{ return m_subnetIdentifier; }
+
+    /**
+     * <p>The system-assigned identifier for the subnet.</p>
+     */
+    inline bool SubnetIdentifierHasBeenSet() const { return m_subnetIdentifierHasBeenSet; }
+
+    /**
+     * <p>The system-assigned identifier for the subnet.</p>
+     */
+    inline void SetSubnetIdentifier(const Aws::String& value) { m_subnetIdentifierHasBeenSet = true; m_subnetIdentifier = value; }
+
+    /**
+     * <p>The system-assigned identifier for the subnet.</p>
+     */
+    inline void SetSubnetIdentifier(Aws::String&& value) { m_subnetIdentifierHasBeenSet = true; m_subnetIdentifier = std::move(value); }
+
+    /**
+     * <p>The system-assigned identifier for the subnet.</p>
+     */
+    inline void SetSubnetIdentifier(const char* value) { m_subnetIdentifierHasBeenSet = true; m_subnetIdentifier.assign(value); }
+
+    /**
+     * <p>The system-assigned identifier for the subnet.</p>
+     */
+    inline Subnet& WithSubnetIdentifier(const Aws::String& value) { SetSubnetIdentifier(value); return *this;}
+
+    /**
+     * <p>The system-assigned identifier for the subnet.</p>
+     */
+    inline Subnet& WithSubnetIdentifier(Aws::String&& value) { SetSubnetIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>The system-assigned identifier for the subnet.</p>
+     */
+    inline Subnet& WithSubnetIdentifier(const char* value) { SetSubnetIdentifier(value); return *this;}
+
+
+    /**
+     * <p>The Availability Zone (AZ) for the subnet.</p>
+     */
+    inline const Aws::String& GetSubnetAvailabilityZone() const{ return m_subnetAvailabilityZone; }
+
+    /**
+     * <p>The Availability Zone (AZ) for the subnet.</p>
+     */
+    inline bool SubnetAvailabilityZoneHasBeenSet() const { return m_subnetAvailabilityZoneHasBeenSet; }
+
+    /**
+     * <p>The Availability Zone (AZ) for the subnet.</p>
+     */
+    inline void SetSubnetAvailabilityZone(const Aws::String& value) { m_subnetAvailabilityZoneHasBeenSet = true; m_subnetAvailabilityZone = value; }
+
+    /**
+     * <p>The Availability Zone (AZ) for the subnet.</p>
+     */
+    inline void SetSubnetAvailabilityZone(Aws::String&& value) { m_subnetAvailabilityZoneHasBeenSet = true; m_subnetAvailabilityZone = std::move(value); }
+
+    /**
+     * <p>The Availability Zone (AZ) for the subnet.</p>
+     */
+    inline void SetSubnetAvailabilityZone(const char* value) { m_subnetAvailabilityZoneHasBeenSet = true; m_subnetAvailabilityZone.assign(value); }
+
+    /**
+     * <p>The Availability Zone (AZ) for the subnet.</p>
+     */
+    inline Subnet& WithSubnetAvailabilityZone(const Aws::String& value) { SetSubnetAvailabilityZone(value); return *this;}
+
+    /**
+     * <p>The Availability Zone (AZ) for the subnet.</p>
+     */
+    inline Subnet& WithSubnetAvailabilityZone(Aws::String&& value) { SetSubnetAvailabilityZone(std::move(value)); return *this;}
+
+    /**
+     * <p>The Availability Zone (AZ) for the subnet.</p>
+     */
+    inline Subnet& WithSubnetAvailabilityZone(const char* value) { SetSubnetAvailabilityZone(value); return *this;}
+
+  private:
+
+    Aws::String m_subnetIdentifier;
+    bool m_subnetIdentifierHasBeenSet;
+
+    Aws::String m_subnetAvailabilityZone;
+    bool m_subnetAvailabilityZoneHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/SubnetGroup.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/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/dax/model/Subnet.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents the output of one of the following actions:</p> <ul> <li> <p>
+   * <i>CreateSubnetGroup</i> </p> </li> <li> <p> <i>ModifySubnetGroup</i> </p> </li>
+   * </ul><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/SubnetGroup">AWS API
+   * Reference</a></p>
+   */
+  class AWS_DAX_API SubnetGroup
+  {
+  public:
+    SubnetGroup();
+    SubnetGroup(Aws::Utils::Json::JsonView jsonValue);
+    SubnetGroup& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The name of the subnet group.</p>
+     */
+    inline const Aws::String& GetSubnetGroupName() const{ return m_subnetGroupName; }
+
+    /**
+     * <p>The name of the subnet group.</p>
+     */
+    inline bool SubnetGroupNameHasBeenSet() const { return m_subnetGroupNameHasBeenSet; }
+
+    /**
+     * <p>The name of the subnet group.</p>
+     */
+    inline void SetSubnetGroupName(const Aws::String& value) { m_subnetGroupNameHasBeenSet = true; m_subnetGroupName = value; }
+
+    /**
+     * <p>The name of the subnet group.</p>
+     */
+    inline void SetSubnetGroupName(Aws::String&& value) { m_subnetGroupNameHasBeenSet = true; m_subnetGroupName = std::move(value); }
+
+    /**
+     * <p>The name of the subnet group.</p>
+     */
+    inline void SetSubnetGroupName(const char* value) { m_subnetGroupNameHasBeenSet = true; m_subnetGroupName.assign(value); }
+
+    /**
+     * <p>The name of the subnet group.</p>
+     */
+    inline SubnetGroup& WithSubnetGroupName(const Aws::String& value) { SetSubnetGroupName(value); return *this;}
+
+    /**
+     * <p>The name of the subnet group.</p>
+     */
+    inline SubnetGroup& WithSubnetGroupName(Aws::String&& value) { SetSubnetGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the subnet group.</p>
+     */
+    inline SubnetGroup& WithSubnetGroupName(const char* value) { SetSubnetGroupName(value); return *this;}
+
+
+    /**
+     * <p>The description of the subnet group.</p>
+     */
+    inline const Aws::String& GetDescription() const{ return m_description; }
+
+    /**
+     * <p>The description of the subnet group.</p>
+     */
+    inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
+
+    /**
+     * <p>The description of the subnet group.</p>
+     */
+    inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
+
+    /**
+     * <p>The description of the subnet group.</p>
+     */
+    inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
+
+    /**
+     * <p>The description of the subnet group.</p>
+     */
+    inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
+
+    /**
+     * <p>The description of the subnet group.</p>
+     */
+    inline SubnetGroup& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
+
+    /**
+     * <p>The description of the subnet group.</p>
+     */
+    inline SubnetGroup& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
+
+    /**
+     * <p>The description of the subnet group.</p>
+     */
+    inline SubnetGroup& WithDescription(const char* value) { SetDescription(value); return *this;}
+
+
+    /**
+     * <p>The Amazon Virtual Private Cloud identifier (VPC ID) of the subnet group.</p>
+     */
+    inline const Aws::String& GetVpcId() const{ return m_vpcId; }
+
+    /**
+     * <p>The Amazon Virtual Private Cloud identifier (VPC ID) of the subnet group.</p>
+     */
+    inline bool VpcIdHasBeenSet() const { return m_vpcIdHasBeenSet; }
+
+    /**
+     * <p>The Amazon Virtual Private Cloud identifier (VPC ID) of the subnet group.</p>
+     */
+    inline void SetVpcId(const Aws::String& value) { m_vpcIdHasBeenSet = true; m_vpcId = value; }
+
+    /**
+     * <p>The Amazon Virtual Private Cloud identifier (VPC ID) of the subnet group.</p>
+     */
+    inline void SetVpcId(Aws::String&& value) { m_vpcIdHasBeenSet = true; m_vpcId = std::move(value); }
+
+    /**
+     * <p>The Amazon Virtual Private Cloud identifier (VPC ID) of the subnet group.</p>
+     */
+    inline void SetVpcId(const char* value) { m_vpcIdHasBeenSet = true; m_vpcId.assign(value); }
+
+    /**
+     * <p>The Amazon Virtual Private Cloud identifier (VPC ID) of the subnet group.</p>
+     */
+    inline SubnetGroup& WithVpcId(const Aws::String& value) { SetVpcId(value); return *this;}
+
+    /**
+     * <p>The Amazon Virtual Private Cloud identifier (VPC ID) of the subnet group.</p>
+     */
+    inline SubnetGroup& WithVpcId(Aws::String&& value) { SetVpcId(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Virtual Private Cloud identifier (VPC ID) of the subnet group.</p>
+     */
+    inline SubnetGroup& WithVpcId(const char* value) { SetVpcId(value); return *this;}
+
+
+    /**
+     * <p>A list of subnets associated with the subnet group. </p>
+     */
+    inline const Aws::Vector<Subnet>& GetSubnets() const{ return m_subnets; }
+
+    /**
+     * <p>A list of subnets associated with the subnet group. </p>
+     */
+    inline bool SubnetsHasBeenSet() const { return m_subnetsHasBeenSet; }
+
+    /**
+     * <p>A list of subnets associated with the subnet group. </p>
+     */
+    inline void SetSubnets(const Aws::Vector<Subnet>& value) { m_subnetsHasBeenSet = true; m_subnets = value; }
+
+    /**
+     * <p>A list of subnets associated with the subnet group. </p>
+     */
+    inline void SetSubnets(Aws::Vector<Subnet>&& value) { m_subnetsHasBeenSet = true; m_subnets = std::move(value); }
+
+    /**
+     * <p>A list of subnets associated with the subnet group. </p>
+     */
+    inline SubnetGroup& WithSubnets(const Aws::Vector<Subnet>& value) { SetSubnets(value); return *this;}
+
+    /**
+     * <p>A list of subnets associated with the subnet group. </p>
+     */
+    inline SubnetGroup& WithSubnets(Aws::Vector<Subnet>&& value) { SetSubnets(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of subnets associated with the subnet group. </p>
+     */
+    inline SubnetGroup& AddSubnets(const Subnet& value) { m_subnetsHasBeenSet = true; m_subnets.push_back(value); return *this; }
+
+    /**
+     * <p>A list of subnets associated with the subnet group. </p>
+     */
+    inline SubnetGroup& AddSubnets(Subnet&& value) { m_subnetsHasBeenSet = true; m_subnets.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_subnetGroupName;
+    bool m_subnetGroupNameHasBeenSet;
+
+    Aws::String m_description;
+    bool m_descriptionHasBeenSet;
+
+    Aws::String m_vpcId;
+    bool m_vpcIdHasBeenSet;
+
+    Aws::Vector<Subnet> m_subnets;
+    bool m_subnetsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/Tag.h

@@ -0,0 +1,153 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   * <p>A description of a tag. Every tag is a key-value pair. You can add up to 50
+   * tags to a single DAX cluster.</p> <p>AWS-assigned tag names and values are
+   * automatically assigned the <code>aws:</code> prefix, which the user cannot
+   * assign. AWS-assigned tag names do not count towards the tag limit of 50.
+   * User-assigned tag names have the prefix <code>user:</code>.</p> <p>You cannot
+   * backdate the application of a tag.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/Tag">AWS API
+   * Reference</a></p>
+   */
+  class AWS_DAX_API Tag
+  {
+  public:
+    Tag();
+    Tag(Aws::Utils::Json::JsonView jsonValue);
+    Tag& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The key for the tag. Tag keys are case sensitive. Every DAX cluster can only
+     * have one tag with the same key. If you try to add an existing tag (same key),
+     * the existing tag value will be updated to the new value.</p>
+     */
+    inline const Aws::String& GetKey() const{ return m_key; }
+
+    /**
+     * <p>The key for the tag. Tag keys are case sensitive. Every DAX cluster can only
+     * have one tag with the same key. If you try to add an existing tag (same key),
+     * the existing tag value will be updated to the new value.</p>
+     */
+    inline bool KeyHasBeenSet() const { return m_keyHasBeenSet; }
+
+    /**
+     * <p>The key for the tag. Tag keys are case sensitive. Every DAX cluster can only
+     * have one tag with the same key. If you try to add an existing tag (same key),
+     * the existing tag value will be updated to the new value.</p>
+     */
+    inline void SetKey(const Aws::String& value) { m_keyHasBeenSet = true; m_key = value; }
+
+    /**
+     * <p>The key for the tag. Tag keys are case sensitive. Every DAX cluster can only
+     * have one tag with the same key. If you try to add an existing tag (same key),
+     * the existing tag value will be updated to the new value.</p>
+     */
+    inline void SetKey(Aws::String&& value) { m_keyHasBeenSet = true; m_key = std::move(value); }
+
+    /**
+     * <p>The key for the tag. Tag keys are case sensitive. Every DAX cluster can only
+     * have one tag with the same key. If you try to add an existing tag (same key),
+     * the existing tag value will be updated to the new value.</p>
+     */
+    inline void SetKey(const char* value) { m_keyHasBeenSet = true; m_key.assign(value); }
+
+    /**
+     * <p>The key for the tag. Tag keys are case sensitive. Every DAX cluster can only
+     * have one tag with the same key. If you try to add an existing tag (same key),
+     * the existing tag value will be updated to the new value.</p>
+     */
+    inline Tag& WithKey(const Aws::String& value) { SetKey(value); return *this;}
+
+    /**
+     * <p>The key for the tag. Tag keys are case sensitive. Every DAX cluster can only
+     * have one tag with the same key. If you try to add an existing tag (same key),
+     * the existing tag value will be updated to the new value.</p>
+     */
+    inline Tag& WithKey(Aws::String&& value) { SetKey(std::move(value)); return *this;}
+
+    /**
+     * <p>The key for the tag. Tag keys are case sensitive. Every DAX cluster can only
+     * have one tag with the same key. If you try to add an existing tag (same key),
+     * the existing tag value will be updated to the new value.</p>
+     */
+    inline Tag& WithKey(const char* value) { SetKey(value); return *this;}
+
+
+    /**
+     * <p>The value of the tag. Tag values are case-sensitive and can be null. </p>
+     */
+    inline const Aws::String& GetValue() const{ return m_value; }
+
+    /**
+     * <p>The value of the tag. Tag values are case-sensitive and can be null. </p>
+     */
+    inline bool ValueHasBeenSet() const { return m_valueHasBeenSet; }
+
+    /**
+     * <p>The value of the tag. Tag values are case-sensitive and can be null. </p>
+     */
+    inline void SetValue(const Aws::String& value) { m_valueHasBeenSet = true; m_value = value; }
+
+    /**
+     * <p>The value of the tag. Tag values are case-sensitive and can be null. </p>
+     */
+    inline void SetValue(Aws::String&& value) { m_valueHasBeenSet = true; m_value = std::move(value); }
+
+    /**
+     * <p>The value of the tag. Tag values are case-sensitive and can be null. </p>
+     */
+    inline void SetValue(const char* value) { m_valueHasBeenSet = true; m_value.assign(value); }
+
+    /**
+     * <p>The value of the tag. Tag values are case-sensitive and can be null. </p>
+     */
+    inline Tag& WithValue(const Aws::String& value) { SetValue(value); return *this;}
+
+    /**
+     * <p>The value of the tag. Tag values are case-sensitive and can be null. </p>
+     */
+    inline Tag& WithValue(Aws::String&& value) { SetValue(std::move(value)); return *this;}
+
+    /**
+     * <p>The value of the tag. Tag values are case-sensitive and can be null. </p>
+     */
+    inline Tag& WithValue(const char* value) { SetValue(value); return *this;}
+
+  private:
+
+    Aws::String m_key;
+    bool m_keyHasBeenSet;
+
+    Aws::String m_value;
+    bool m_valueHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/TagResourceRequest.h

@@ -0,0 +1,131 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/DAXRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/dax/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DAX_API TagResourceRequest : public DAXRequest
+  {
+  public:
+    TagResourceRequest();
+
+    // 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 "TagResource"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the DAX resource to which tags should be added.</p>
+     */
+    inline const Aws::String& GetResourceName() const{ return m_resourceName; }
+
+    /**
+     * <p>The name of the DAX resource to which tags should be added.</p>
+     */
+    inline bool ResourceNameHasBeenSet() const { return m_resourceNameHasBeenSet; }
+
+    /**
+     * <p>The name of the DAX resource to which tags should be added.</p>
+     */
+    inline void SetResourceName(const Aws::String& value) { m_resourceNameHasBeenSet = true; m_resourceName = value; }
+
+    /**
+     * <p>The name of the DAX resource to which tags should be added.</p>
+     */
+    inline void SetResourceName(Aws::String&& value) { m_resourceNameHasBeenSet = true; m_resourceName = std::move(value); }
+
+    /**
+     * <p>The name of the DAX resource to which tags should be added.</p>
+     */
+    inline void SetResourceName(const char* value) { m_resourceNameHasBeenSet = true; m_resourceName.assign(value); }
+
+    /**
+     * <p>The name of the DAX resource to which tags should be added.</p>
+     */
+    inline TagResourceRequest& WithResourceName(const Aws::String& value) { SetResourceName(value); return *this;}
+
+    /**
+     * <p>The name of the DAX resource to which tags should be added.</p>
+     */
+    inline TagResourceRequest& WithResourceName(Aws::String&& value) { SetResourceName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the DAX resource to which tags should be added.</p>
+     */
+    inline TagResourceRequest& WithResourceName(const char* value) { SetResourceName(value); return *this;}
+
+
+    /**
+     * <p>The tags to be assigned to the DAX resource. </p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>The tags to be assigned to the DAX resource. </p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>The tags to be assigned to the DAX resource. </p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>The tags to be assigned to the DAX resource. </p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>The tags to be assigned to the DAX resource. </p>
+     */
+    inline TagResourceRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>The tags to be assigned to the DAX resource. </p>
+     */
+    inline TagResourceRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>The tags to be assigned to the DAX resource. </p>
+     */
+    inline TagResourceRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>The tags to be assigned to the DAX resource. </p>
+     */
+    inline TagResourceRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_resourceName;
+    bool m_resourceNameHasBeenSet;
+
+    Aws::Vector<Tag> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/TagResourceResult.h

@@ -0,0 +1,78 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/dax/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+  class AWS_DAX_API TagResourceResult
+  {
+  public:
+    TagResourceResult();
+    TagResourceResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    TagResourceResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The list of tags that are associated with the DAX resource.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>The list of tags that are associated with the DAX resource.</p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tags = value; }
+
+    /**
+     * <p>The list of tags that are associated with the DAX resource.</p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tags = std::move(value); }
+
+    /**
+     * <p>The list of tags that are associated with the DAX resource.</p>
+     */
+    inline TagResourceResult& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>The list of tags that are associated with the DAX resource.</p>
+     */
+    inline TagResourceResult& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>The list of tags that are associated with the DAX resource.</p>
+     */
+    inline TagResourceResult& AddTags(const Tag& value) { m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>The list of tags that are associated with the DAX resource.</p>
+     */
+    inline TagResourceResult& AddTags(Tag&& value) { m_tags.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::Vector<Tag> m_tags;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/UntagResourceRequest.h

@@ -0,0 +1,144 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/DAXRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DAX_API UntagResourceRequest : public DAXRequest
+  {
+  public:
+    UntagResourceRequest();
+
+    // 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 "UntagResource"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the DAX resource from which the tags should be removed.</p>
+     */
+    inline const Aws::String& GetResourceName() const{ return m_resourceName; }
+
+    /**
+     * <p>The name of the DAX resource from which the tags should be removed.</p>
+     */
+    inline bool ResourceNameHasBeenSet() const { return m_resourceNameHasBeenSet; }
+
+    /**
+     * <p>The name of the DAX resource from which the tags should be removed.</p>
+     */
+    inline void SetResourceName(const Aws::String& value) { m_resourceNameHasBeenSet = true; m_resourceName = value; }
+
+    /**
+     * <p>The name of the DAX resource from which the tags should be removed.</p>
+     */
+    inline void SetResourceName(Aws::String&& value) { m_resourceNameHasBeenSet = true; m_resourceName = std::move(value); }
+
+    /**
+     * <p>The name of the DAX resource from which the tags should be removed.</p>
+     */
+    inline void SetResourceName(const char* value) { m_resourceNameHasBeenSet = true; m_resourceName.assign(value); }
+
+    /**
+     * <p>The name of the DAX resource from which the tags should be removed.</p>
+     */
+    inline UntagResourceRequest& WithResourceName(const Aws::String& value) { SetResourceName(value); return *this;}
+
+    /**
+     * <p>The name of the DAX resource from which the tags should be removed.</p>
+     */
+    inline UntagResourceRequest& WithResourceName(Aws::String&& value) { SetResourceName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the DAX resource from which the tags should be removed.</p>
+     */
+    inline UntagResourceRequest& WithResourceName(const char* value) { SetResourceName(value); return *this;}
+
+
+    /**
+     * <p>A list of tag keys. If the DAX cluster has any tags with these keys, then the
+     * tags are removed from the cluster.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetTagKeys() const{ return m_tagKeys; }
+
+    /**
+     * <p>A list of tag keys. If the DAX cluster has any tags with these keys, then the
+     * tags are removed from the cluster.</p>
+     */
+    inline bool TagKeysHasBeenSet() const { return m_tagKeysHasBeenSet; }
+
+    /**
+     * <p>A list of tag keys. If the DAX cluster has any tags with these keys, then the
+     * tags are removed from the cluster.</p>
+     */
+    inline void SetTagKeys(const Aws::Vector<Aws::String>& value) { m_tagKeysHasBeenSet = true; m_tagKeys = value; }
+
+    /**
+     * <p>A list of tag keys. If the DAX cluster has any tags with these keys, then the
+     * tags are removed from the cluster.</p>
+     */
+    inline void SetTagKeys(Aws::Vector<Aws::String>&& value) { m_tagKeysHasBeenSet = true; m_tagKeys = std::move(value); }
+
+    /**
+     * <p>A list of tag keys. If the DAX cluster has any tags with these keys, then the
+     * tags are removed from the cluster.</p>
+     */
+    inline UntagResourceRequest& WithTagKeys(const Aws::Vector<Aws::String>& value) { SetTagKeys(value); return *this;}
+
+    /**
+     * <p>A list of tag keys. If the DAX cluster has any tags with these keys, then the
+     * tags are removed from the cluster.</p>
+     */
+    inline UntagResourceRequest& WithTagKeys(Aws::Vector<Aws::String>&& value) { SetTagKeys(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of tag keys. If the DAX cluster has any tags with these keys, then the
+     * tags are removed from the cluster.</p>
+     */
+    inline UntagResourceRequest& AddTagKeys(const Aws::String& value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(value); return *this; }
+
+    /**
+     * <p>A list of tag keys. If the DAX cluster has any tags with these keys, then the
+     * tags are removed from the cluster.</p>
+     */
+    inline UntagResourceRequest& AddTagKeys(Aws::String&& value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>A list of tag keys. If the DAX cluster has any tags with these keys, then the
+     * tags are removed from the cluster.</p>
+     */
+    inline UntagResourceRequest& AddTagKeys(const char* value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(value); return *this; }
+
+  private:
+
+    Aws::String m_resourceName;
+    bool m_resourceNameHasBeenSet;
+
+    Aws::Vector<Aws::String> m_tagKeys;
+    bool m_tagKeysHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/UntagResourceResult.h

@@ -0,0 +1,78 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/dax/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+  class AWS_DAX_API UntagResourceResult
+  {
+  public:
+    UntagResourceResult();
+    UntagResourceResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    UntagResourceResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The tag keys that have been removed from the cluster.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>The tag keys that have been removed from the cluster.</p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tags = value; }
+
+    /**
+     * <p>The tag keys that have been removed from the cluster.</p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tags = std::move(value); }
+
+    /**
+     * <p>The tag keys that have been removed from the cluster.</p>
+     */
+    inline UntagResourceResult& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>The tag keys that have been removed from the cluster.</p>
+     */
+    inline UntagResourceResult& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>The tag keys that have been removed from the cluster.</p>
+     */
+    inline UntagResourceResult& AddTags(const Tag& value) { m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>The tag keys that have been removed from the cluster.</p>
+     */
+    inline UntagResourceResult& AddTags(Tag&& value) { m_tags.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::Vector<Tag> m_tags;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/UpdateClusterRequest.h

@@ -0,0 +1,397 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/DAXRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DAX_API UpdateClusterRequest : public DAXRequest
+  {
+  public:
+    UpdateClusterRequest();
+
+    // 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 "UpdateCluster"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the DAX cluster to be modified.</p>
+     */
+    inline const Aws::String& GetClusterName() const{ return m_clusterName; }
+
+    /**
+     * <p>The name of the DAX cluster to be modified.</p>
+     */
+    inline bool ClusterNameHasBeenSet() const { return m_clusterNameHasBeenSet; }
+
+    /**
+     * <p>The name of the DAX cluster to be modified.</p>
+     */
+    inline void SetClusterName(const Aws::String& value) { m_clusterNameHasBeenSet = true; m_clusterName = value; }
+
+    /**
+     * <p>The name of the DAX cluster to be modified.</p>
+     */
+    inline void SetClusterName(Aws::String&& value) { m_clusterNameHasBeenSet = true; m_clusterName = std::move(value); }
+
+    /**
+     * <p>The name of the DAX cluster to be modified.</p>
+     */
+    inline void SetClusterName(const char* value) { m_clusterNameHasBeenSet = true; m_clusterName.assign(value); }
+
+    /**
+     * <p>The name of the DAX cluster to be modified.</p>
+     */
+    inline UpdateClusterRequest& WithClusterName(const Aws::String& value) { SetClusterName(value); return *this;}
+
+    /**
+     * <p>The name of the DAX cluster to be modified.</p>
+     */
+    inline UpdateClusterRequest& WithClusterName(Aws::String&& value) { SetClusterName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the DAX cluster to be modified.</p>
+     */
+    inline UpdateClusterRequest& WithClusterName(const char* value) { SetClusterName(value); return *this;}
+
+
+    /**
+     * <p>A description of the changes being made to the cluster.</p>
+     */
+    inline const Aws::String& GetDescription() const{ return m_description; }
+
+    /**
+     * <p>A description of the changes being made to the cluster.</p>
+     */
+    inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
+
+    /**
+     * <p>A description of the changes being made to the cluster.</p>
+     */
+    inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
+
+    /**
+     * <p>A description of the changes being made to the cluster.</p>
+     */
+    inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
+
+    /**
+     * <p>A description of the changes being made to the cluster.</p>
+     */
+    inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
+
+    /**
+     * <p>A description of the changes being made to the cluster.</p>
+     */
+    inline UpdateClusterRequest& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
+
+    /**
+     * <p>A description of the changes being made to the cluster.</p>
+     */
+    inline UpdateClusterRequest& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
+
+    /**
+     * <p>A description of the changes being made to the cluster.</p>
+     */
+    inline UpdateClusterRequest& WithDescription(const char* value) { SetDescription(value); return *this;}
+
+
+    /**
+     * <p>A range of time when maintenance of DAX cluster software will be performed.
+     * For example: <code>sun:01:00-sun:09:00</code>. Cluster maintenance normally
+     * takes less than 30 minutes, and is performed automatically within the
+     * maintenance window.</p>
+     */
+    inline const Aws::String& GetPreferredMaintenanceWindow() const{ return m_preferredMaintenanceWindow; }
+
+    /**
+     * <p>A range of time when maintenance of DAX cluster software will be performed.
+     * For example: <code>sun:01:00-sun:09:00</code>. Cluster maintenance normally
+     * takes less than 30 minutes, and is performed automatically within the
+     * maintenance window.</p>
+     */
+    inline bool PreferredMaintenanceWindowHasBeenSet() const { return m_preferredMaintenanceWindowHasBeenSet; }
+
+    /**
+     * <p>A range of time when maintenance of DAX cluster software will be performed.
+     * For example: <code>sun:01:00-sun:09:00</code>. Cluster maintenance normally
+     * takes less than 30 minutes, and is performed automatically within the
+     * maintenance window.</p>
+     */
+    inline void SetPreferredMaintenanceWindow(const Aws::String& value) { m_preferredMaintenanceWindowHasBeenSet = true; m_preferredMaintenanceWindow = value; }
+
+    /**
+     * <p>A range of time when maintenance of DAX cluster software will be performed.
+     * For example: <code>sun:01:00-sun:09:00</code>. Cluster maintenance normally
+     * takes less than 30 minutes, and is performed automatically within the
+     * maintenance window.</p>
+     */
+    inline void SetPreferredMaintenanceWindow(Aws::String&& value) { m_preferredMaintenanceWindowHasBeenSet = true; m_preferredMaintenanceWindow = std::move(value); }
+
+    /**
+     * <p>A range of time when maintenance of DAX cluster software will be performed.
+     * For example: <code>sun:01:00-sun:09:00</code>. Cluster maintenance normally
+     * takes less than 30 minutes, and is performed automatically within the
+     * maintenance window.</p>
+     */
+    inline void SetPreferredMaintenanceWindow(const char* value) { m_preferredMaintenanceWindowHasBeenSet = true; m_preferredMaintenanceWindow.assign(value); }
+
+    /**
+     * <p>A range of time when maintenance of DAX cluster software will be performed.
+     * For example: <code>sun:01:00-sun:09:00</code>. Cluster maintenance normally
+     * takes less than 30 minutes, and is performed automatically within the
+     * maintenance window.</p>
+     */
+    inline UpdateClusterRequest& WithPreferredMaintenanceWindow(const Aws::String& value) { SetPreferredMaintenanceWindow(value); return *this;}
+
+    /**
+     * <p>A range of time when maintenance of DAX cluster software will be performed.
+     * For example: <code>sun:01:00-sun:09:00</code>. Cluster maintenance normally
+     * takes less than 30 minutes, and is performed automatically within the
+     * maintenance window.</p>
+     */
+    inline UpdateClusterRequest& WithPreferredMaintenanceWindow(Aws::String&& value) { SetPreferredMaintenanceWindow(std::move(value)); return *this;}
+
+    /**
+     * <p>A range of time when maintenance of DAX cluster software will be performed.
+     * For example: <code>sun:01:00-sun:09:00</code>. Cluster maintenance normally
+     * takes less than 30 minutes, and is performed automatically within the
+     * maintenance window.</p>
+     */
+    inline UpdateClusterRequest& WithPreferredMaintenanceWindow(const char* value) { SetPreferredMaintenanceWindow(value); return *this;}
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that identifies the topic.</p>
+     */
+    inline const Aws::String& GetNotificationTopicArn() const{ return m_notificationTopicArn; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that identifies the topic.</p>
+     */
+    inline bool NotificationTopicArnHasBeenSet() const { return m_notificationTopicArnHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that identifies the topic.</p>
+     */
+    inline void SetNotificationTopicArn(const Aws::String& value) { m_notificationTopicArnHasBeenSet = true; m_notificationTopicArn = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that identifies the topic.</p>
+     */
+    inline void SetNotificationTopicArn(Aws::String&& value) { m_notificationTopicArnHasBeenSet = true; m_notificationTopicArn = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that identifies the topic.</p>
+     */
+    inline void SetNotificationTopicArn(const char* value) { m_notificationTopicArnHasBeenSet = true; m_notificationTopicArn.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that identifies the topic.</p>
+     */
+    inline UpdateClusterRequest& WithNotificationTopicArn(const Aws::String& value) { SetNotificationTopicArn(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that identifies the topic.</p>
+     */
+    inline UpdateClusterRequest& WithNotificationTopicArn(Aws::String&& value) { SetNotificationTopicArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) that identifies the topic.</p>
+     */
+    inline UpdateClusterRequest& WithNotificationTopicArn(const char* value) { SetNotificationTopicArn(value); return *this;}
+
+
+    /**
+     * <p>The current state of the topic.</p>
+     */
+    inline const Aws::String& GetNotificationTopicStatus() const{ return m_notificationTopicStatus; }
+
+    /**
+     * <p>The current state of the topic.</p>
+     */
+    inline bool NotificationTopicStatusHasBeenSet() const { return m_notificationTopicStatusHasBeenSet; }
+
+    /**
+     * <p>The current state of the topic.</p>
+     */
+    inline void SetNotificationTopicStatus(const Aws::String& value) { m_notificationTopicStatusHasBeenSet = true; m_notificationTopicStatus = value; }
+
+    /**
+     * <p>The current state of the topic.</p>
+     */
+    inline void SetNotificationTopicStatus(Aws::String&& value) { m_notificationTopicStatusHasBeenSet = true; m_notificationTopicStatus = std::move(value); }
+
+    /**
+     * <p>The current state of the topic.</p>
+     */
+    inline void SetNotificationTopicStatus(const char* value) { m_notificationTopicStatusHasBeenSet = true; m_notificationTopicStatus.assign(value); }
+
+    /**
+     * <p>The current state of the topic.</p>
+     */
+    inline UpdateClusterRequest& WithNotificationTopicStatus(const Aws::String& value) { SetNotificationTopicStatus(value); return *this;}
+
+    /**
+     * <p>The current state of the topic.</p>
+     */
+    inline UpdateClusterRequest& WithNotificationTopicStatus(Aws::String&& value) { SetNotificationTopicStatus(std::move(value)); return *this;}
+
+    /**
+     * <p>The current state of the topic.</p>
+     */
+    inline UpdateClusterRequest& WithNotificationTopicStatus(const char* value) { SetNotificationTopicStatus(value); return *this;}
+
+
+    /**
+     * <p>The name of a parameter group for this cluster.</p>
+     */
+    inline const Aws::String& GetParameterGroupName() const{ return m_parameterGroupName; }
+
+    /**
+     * <p>The name of a parameter group for this cluster.</p>
+     */
+    inline bool ParameterGroupNameHasBeenSet() const { return m_parameterGroupNameHasBeenSet; }
+
+    /**
+     * <p>The name of a parameter group for this cluster.</p>
+     */
+    inline void SetParameterGroupName(const Aws::String& value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName = value; }
+
+    /**
+     * <p>The name of a parameter group for this cluster.</p>
+     */
+    inline void SetParameterGroupName(Aws::String&& value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName = std::move(value); }
+
+    /**
+     * <p>The name of a parameter group for this cluster.</p>
+     */
+    inline void SetParameterGroupName(const char* value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName.assign(value); }
+
+    /**
+     * <p>The name of a parameter group for this cluster.</p>
+     */
+    inline UpdateClusterRequest& WithParameterGroupName(const Aws::String& value) { SetParameterGroupName(value); return *this;}
+
+    /**
+     * <p>The name of a parameter group for this cluster.</p>
+     */
+    inline UpdateClusterRequest& WithParameterGroupName(Aws::String&& value) { SetParameterGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of a parameter group for this cluster.</p>
+     */
+    inline UpdateClusterRequest& WithParameterGroupName(const char* value) { SetParameterGroupName(value); return *this;}
+
+
+    /**
+     * <p>A list of user-specified security group IDs to be assigned to each node in
+     * the DAX cluster. If this parameter is not specified, DAX assigns the default VPC
+     * security group to each node.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetSecurityGroupIds() const{ return m_securityGroupIds; }
+
+    /**
+     * <p>A list of user-specified security group IDs to be assigned to each node in
+     * the DAX cluster. If this parameter is not specified, DAX assigns the default VPC
+     * security group to each node.</p>
+     */
+    inline bool SecurityGroupIdsHasBeenSet() const { return m_securityGroupIdsHasBeenSet; }
+
+    /**
+     * <p>A list of user-specified security group IDs to be assigned to each node in
+     * the DAX cluster. If this parameter is not specified, DAX assigns the default VPC
+     * security group to each node.</p>
+     */
+    inline void SetSecurityGroupIds(const Aws::Vector<Aws::String>& value) { m_securityGroupIdsHasBeenSet = true; m_securityGroupIds = value; }
+
+    /**
+     * <p>A list of user-specified security group IDs to be assigned to each node in
+     * the DAX cluster. If this parameter is not specified, DAX assigns the default VPC
+     * security group to each node.</p>
+     */
+    inline void SetSecurityGroupIds(Aws::Vector<Aws::String>&& value) { m_securityGroupIdsHasBeenSet = true; m_securityGroupIds = std::move(value); }
+
+    /**
+     * <p>A list of user-specified security group IDs to be assigned to each node in
+     * the DAX cluster. If this parameter is not specified, DAX assigns the default VPC
+     * security group to each node.</p>
+     */
+    inline UpdateClusterRequest& WithSecurityGroupIds(const Aws::Vector<Aws::String>& value) { SetSecurityGroupIds(value); return *this;}
+
+    /**
+     * <p>A list of user-specified security group IDs to be assigned to each node in
+     * the DAX cluster. If this parameter is not specified, DAX assigns the default VPC
+     * security group to each node.</p>
+     */
+    inline UpdateClusterRequest& WithSecurityGroupIds(Aws::Vector<Aws::String>&& value) { SetSecurityGroupIds(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of user-specified security group IDs to be assigned to each node in
+     * the DAX cluster. If this parameter is not specified, DAX assigns the default VPC
+     * security group to each node.</p>
+     */
+    inline UpdateClusterRequest& AddSecurityGroupIds(const Aws::String& value) { m_securityGroupIdsHasBeenSet = true; m_securityGroupIds.push_back(value); return *this; }
+
+    /**
+     * <p>A list of user-specified security group IDs to be assigned to each node in
+     * the DAX cluster. If this parameter is not specified, DAX assigns the default VPC
+     * security group to each node.</p>
+     */
+    inline UpdateClusterRequest& AddSecurityGroupIds(Aws::String&& value) { m_securityGroupIdsHasBeenSet = true; m_securityGroupIds.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>A list of user-specified security group IDs to be assigned to each node in
+     * the DAX cluster. If this parameter is not specified, DAX assigns the default VPC
+     * security group to each node.</p>
+     */
+    inline UpdateClusterRequest& AddSecurityGroupIds(const char* value) { m_securityGroupIdsHasBeenSet = true; m_securityGroupIds.push_back(value); return *this; }
+
+  private:
+
+    Aws::String m_clusterName;
+    bool m_clusterNameHasBeenSet;
+
+    Aws::String m_description;
+    bool m_descriptionHasBeenSet;
+
+    Aws::String m_preferredMaintenanceWindow;
+    bool m_preferredMaintenanceWindowHasBeenSet;
+
+    Aws::String m_notificationTopicArn;
+    bool m_notificationTopicArnHasBeenSet;
+
+    Aws::String m_notificationTopicStatus;
+    bool m_notificationTopicStatusHasBeenSet;
+
+    Aws::String m_parameterGroupName;
+    bool m_parameterGroupNameHasBeenSet;
+
+    Aws::Vector<Aws::String> m_securityGroupIds;
+    bool m_securityGroupIdsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/UpdateClusterResult.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/model/Cluster.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+  class AWS_DAX_API UpdateClusterResult
+  {
+  public:
+    UpdateClusterResult();
+    UpdateClusterResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    UpdateClusterResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>A description of the DAX cluster, after it has been modified.</p>
+     */
+    inline const Cluster& GetCluster() const{ return m_cluster; }
+
+    /**
+     * <p>A description of the DAX cluster, after it has been modified.</p>
+     */
+    inline void SetCluster(const Cluster& value) { m_cluster = value; }
+
+    /**
+     * <p>A description of the DAX cluster, after it has been modified.</p>
+     */
+    inline void SetCluster(Cluster&& value) { m_cluster = std::move(value); }
+
+    /**
+     * <p>A description of the DAX cluster, after it has been modified.</p>
+     */
+    inline UpdateClusterResult& WithCluster(const Cluster& value) { SetCluster(value); return *this;}
+
+    /**
+     * <p>A description of the DAX cluster, after it has been modified.</p>
+     */
+    inline UpdateClusterResult& WithCluster(Cluster&& value) { SetCluster(std::move(value)); return *this;}
+
+  private:
+
+    Cluster m_cluster;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/UpdateParameterGroupRequest.h

@@ -0,0 +1,139 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/DAXRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/dax/model/ParameterNameValue.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DAX_API UpdateParameterGroupRequest : public DAXRequest
+  {
+  public:
+    UpdateParameterGroupRequest();
+
+    // 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 "UpdateParameterGroup"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline const Aws::String& GetParameterGroupName() const{ return m_parameterGroupName; }
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline bool ParameterGroupNameHasBeenSet() const { return m_parameterGroupNameHasBeenSet; }
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline void SetParameterGroupName(const Aws::String& value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName = value; }
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline void SetParameterGroupName(Aws::String&& value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName = std::move(value); }
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline void SetParameterGroupName(const char* value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName.assign(value); }
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline UpdateParameterGroupRequest& WithParameterGroupName(const Aws::String& value) { SetParameterGroupName(value); return *this;}
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline UpdateParameterGroupRequest& WithParameterGroupName(Aws::String&& value) { SetParameterGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the parameter group.</p>
+     */
+    inline UpdateParameterGroupRequest& WithParameterGroupName(const char* value) { SetParameterGroupName(value); return *this;}
+
+
+    /**
+     * <p>An array of name-value pairs for the parameters in the group. Each element in
+     * the array represents a single parameter.</p>
+     */
+    inline const Aws::Vector<ParameterNameValue>& GetParameterNameValues() const{ return m_parameterNameValues; }
+
+    /**
+     * <p>An array of name-value pairs for the parameters in the group. Each element in
+     * the array represents a single parameter.</p>
+     */
+    inline bool ParameterNameValuesHasBeenSet() const { return m_parameterNameValuesHasBeenSet; }
+
+    /**
+     * <p>An array of name-value pairs for the parameters in the group. Each element in
+     * the array represents a single parameter.</p>
+     */
+    inline void SetParameterNameValues(const Aws::Vector<ParameterNameValue>& value) { m_parameterNameValuesHasBeenSet = true; m_parameterNameValues = value; }
+
+    /**
+     * <p>An array of name-value pairs for the parameters in the group. Each element in
+     * the array represents a single parameter.</p>
+     */
+    inline void SetParameterNameValues(Aws::Vector<ParameterNameValue>&& value) { m_parameterNameValuesHasBeenSet = true; m_parameterNameValues = std::move(value); }
+
+    /**
+     * <p>An array of name-value pairs for the parameters in the group. Each element in
+     * the array represents a single parameter.</p>
+     */
+    inline UpdateParameterGroupRequest& WithParameterNameValues(const Aws::Vector<ParameterNameValue>& value) { SetParameterNameValues(value); return *this;}
+
+    /**
+     * <p>An array of name-value pairs for the parameters in the group. Each element in
+     * the array represents a single parameter.</p>
+     */
+    inline UpdateParameterGroupRequest& WithParameterNameValues(Aws::Vector<ParameterNameValue>&& value) { SetParameterNameValues(std::move(value)); return *this;}
+
+    /**
+     * <p>An array of name-value pairs for the parameters in the group. Each element in
+     * the array represents a single parameter.</p>
+     */
+    inline UpdateParameterGroupRequest& AddParameterNameValues(const ParameterNameValue& value) { m_parameterNameValuesHasBeenSet = true; m_parameterNameValues.push_back(value); return *this; }
+
+    /**
+     * <p>An array of name-value pairs for the parameters in the group. Each element in
+     * the array represents a single parameter.</p>
+     */
+    inline UpdateParameterGroupRequest& AddParameterNameValues(ParameterNameValue&& value) { m_parameterNameValuesHasBeenSet = true; m_parameterNameValues.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_parameterGroupName;
+    bool m_parameterGroupNameHasBeenSet;
+
+    Aws::Vector<ParameterNameValue> m_parameterNameValues;
+    bool m_parameterNameValuesHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/UpdateParameterGroupResult.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/model/ParameterGroup.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+  class AWS_DAX_API UpdateParameterGroupResult
+  {
+  public:
+    UpdateParameterGroupResult();
+    UpdateParameterGroupResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    UpdateParameterGroupResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The parameter group that has been modified.</p>
+     */
+    inline const ParameterGroup& GetParameterGroup() const{ return m_parameterGroup; }
+
+    /**
+     * <p>The parameter group that has been modified.</p>
+     */
+    inline void SetParameterGroup(const ParameterGroup& value) { m_parameterGroup = value; }
+
+    /**
+     * <p>The parameter group that has been modified.</p>
+     */
+    inline void SetParameterGroup(ParameterGroup&& value) { m_parameterGroup = std::move(value); }
+
+    /**
+     * <p>The parameter group that has been modified.</p>
+     */
+    inline UpdateParameterGroupResult& WithParameterGroup(const ParameterGroup& value) { SetParameterGroup(value); return *this;}
+
+    /**
+     * <p>The parameter group that has been modified.</p>
+     */
+    inline UpdateParameterGroupResult& WithParameterGroup(ParameterGroup&& value) { SetParameterGroup(std::move(value)); return *this;}
+
+  private:
+
+    ParameterGroup m_parameterGroup;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/UpdateSubnetGroupRequest.h

@@ -0,0 +1,179 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/DAXRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <utility>
+
+namespace Aws
+{
+namespace DAX
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_DAX_API UpdateSubnetGroupRequest : public DAXRequest
+  {
+  public:
+    UpdateSubnetGroupRequest();
+
+    // 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 "UpdateSubnetGroup"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the subnet group.</p>
+     */
+    inline const Aws::String& GetSubnetGroupName() const{ return m_subnetGroupName; }
+
+    /**
+     * <p>The name of the subnet group.</p>
+     */
+    inline bool SubnetGroupNameHasBeenSet() const { return m_subnetGroupNameHasBeenSet; }
+
+    /**
+     * <p>The name of the subnet group.</p>
+     */
+    inline void SetSubnetGroupName(const Aws::String& value) { m_subnetGroupNameHasBeenSet = true; m_subnetGroupName = value; }
+
+    /**
+     * <p>The name of the subnet group.</p>
+     */
+    inline void SetSubnetGroupName(Aws::String&& value) { m_subnetGroupNameHasBeenSet = true; m_subnetGroupName = std::move(value); }
+
+    /**
+     * <p>The name of the subnet group.</p>
+     */
+    inline void SetSubnetGroupName(const char* value) { m_subnetGroupNameHasBeenSet = true; m_subnetGroupName.assign(value); }
+
+    /**
+     * <p>The name of the subnet group.</p>
+     */
+    inline UpdateSubnetGroupRequest& WithSubnetGroupName(const Aws::String& value) { SetSubnetGroupName(value); return *this;}
+
+    /**
+     * <p>The name of the subnet group.</p>
+     */
+    inline UpdateSubnetGroupRequest& WithSubnetGroupName(Aws::String&& value) { SetSubnetGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the subnet group.</p>
+     */
+    inline UpdateSubnetGroupRequest& WithSubnetGroupName(const char* value) { SetSubnetGroupName(value); return *this;}
+
+
+    /**
+     * <p>A description of the subnet group.</p>
+     */
+    inline const Aws::String& GetDescription() const{ return m_description; }
+
+    /**
+     * <p>A description of the subnet group.</p>
+     */
+    inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
+
+    /**
+     * <p>A description of the subnet group.</p>
+     */
+    inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
+
+    /**
+     * <p>A description of the subnet group.</p>
+     */
+    inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
+
+    /**
+     * <p>A description of the subnet group.</p>
+     */
+    inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
+
+    /**
+     * <p>A description of the subnet group.</p>
+     */
+    inline UpdateSubnetGroupRequest& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
+
+    /**
+     * <p>A description of the subnet group.</p>
+     */
+    inline UpdateSubnetGroupRequest& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
+
+    /**
+     * <p>A description of the subnet group.</p>
+     */
+    inline UpdateSubnetGroupRequest& WithDescription(const char* value) { SetDescription(value); return *this;}
+
+
+    /**
+     * <p>A list of subnet IDs in the subnet group.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetSubnetIds() const{ return m_subnetIds; }
+
+    /**
+     * <p>A list of subnet IDs in the subnet group.</p>
+     */
+    inline bool SubnetIdsHasBeenSet() const { return m_subnetIdsHasBeenSet; }
+
+    /**
+     * <p>A list of subnet IDs in the subnet group.</p>
+     */
+    inline void SetSubnetIds(const Aws::Vector<Aws::String>& value) { m_subnetIdsHasBeenSet = true; m_subnetIds = value; }
+
+    /**
+     * <p>A list of subnet IDs in the subnet group.</p>
+     */
+    inline void SetSubnetIds(Aws::Vector<Aws::String>&& value) { m_subnetIdsHasBeenSet = true; m_subnetIds = std::move(value); }
+
+    /**
+     * <p>A list of subnet IDs in the subnet group.</p>
+     */
+    inline UpdateSubnetGroupRequest& WithSubnetIds(const Aws::Vector<Aws::String>& value) { SetSubnetIds(value); return *this;}
+
+    /**
+     * <p>A list of subnet IDs in the subnet group.</p>
+     */
+    inline UpdateSubnetGroupRequest& WithSubnetIds(Aws::Vector<Aws::String>&& value) { SetSubnetIds(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of subnet IDs in the subnet group.</p>
+     */
+    inline UpdateSubnetGroupRequest& AddSubnetIds(const Aws::String& value) { m_subnetIdsHasBeenSet = true; m_subnetIds.push_back(value); return *this; }
+
+    /**
+     * <p>A list of subnet IDs in the subnet group.</p>
+     */
+    inline UpdateSubnetGroupRequest& AddSubnetIds(Aws::String&& value) { m_subnetIdsHasBeenSet = true; m_subnetIds.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>A list of subnet IDs in the subnet group.</p>
+     */
+    inline UpdateSubnetGroupRequest& AddSubnetIds(const char* value) { m_subnetIdsHasBeenSet = true; m_subnetIds.push_back(value); return *this; }
+
+  private:
+
+    Aws::String m_subnetGroupName;
+    bool m_subnetGroupNameHasBeenSet;
+
+    Aws::String m_description;
+    bool m_descriptionHasBeenSet;
+
+    Aws::Vector<Aws::String> m_subnetIds;
+    bool m_subnetIdsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-dax/include/aws/dax/model/UpdateSubnetGroupResult.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/dax/DAX_EXPORTS.h>
+#include <aws/dax/model/SubnetGroup.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace DAX
+{
+namespace Model
+{
+  class AWS_DAX_API UpdateSubnetGroupResult
+  {
+  public:
+    UpdateSubnetGroupResult();
+    UpdateSubnetGroupResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    UpdateSubnetGroupResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The subnet group that has been modified.</p>
+     */
+    inline const SubnetGroup& GetSubnetGroup() const{ return m_subnetGroup; }
+
+    /**
+     * <p>The subnet group that has been modified.</p>
+     */
+    inline void SetSubnetGroup(const SubnetGroup& value) { m_subnetGroup = value; }
+
+    /**
+     * <p>The subnet group that has been modified.</p>
+     */
+    inline void SetSubnetGroup(SubnetGroup&& value) { m_subnetGroup = std::move(value); }
+
+    /**
+     * <p>The subnet group that has been modified.</p>
+     */
+    inline UpdateSubnetGroupResult& WithSubnetGroup(const SubnetGroup& value) { SetSubnetGroup(value); return *this;}
+
+    /**
+     * <p>The subnet group that has been modified.</p>
+     */
+    inline UpdateSubnetGroupResult& WithSubnetGroup(SubnetGroup&& value) { SetSubnetGroup(std::move(value)); return *this;}
+
+  private:
+
+    SubnetGroup m_subnetGroup;
+  };
+
+} // namespace Model
+} // namespace DAX
+} // namespace Aws