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

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

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

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/RedshiftErrors.h

@@ -0,0 +1,178 @@
+/**
+ * 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/redshift/Redshift_EXPORTS.h>
+
+namespace Aws
+{
+namespace Redshift
+{
+enum class RedshiftErrors
+{
+  //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,
+  ///////////////////////////////////////////////////////////////////////////////////////////
+
+  ACCESS_TO_SNAPSHOT_DENIED_FAULT= static_cast<int>(Aws::Client::CoreErrors::SERVICE_EXTENSION_START_RANGE) + 1,
+  AUTHORIZATION_ALREADY_EXISTS_FAULT,
+  AUTHORIZATION_NOT_FOUND_FAULT,
+  AUTHORIZATION_QUOTA_EXCEEDED_FAULT,
+  BATCH_DELETE_REQUEST_SIZE_EXCEEDED_FAULT,
+  BATCH_MODIFY_CLUSTER_SNAPSHOTS_LIMIT_EXCEEDED_FAULT,
+  BUCKET_NOT_FOUND_FAULT,
+  CLUSTER_ALREADY_EXISTS_FAULT,
+  CLUSTER_NOT_FOUND_FAULT,
+  CLUSTER_ON_LATEST_REVISION_FAULT,
+  CLUSTER_PARAMETER_GROUP_ALREADY_EXISTS_FAULT,
+  CLUSTER_PARAMETER_GROUP_NOT_FOUND_FAULT,
+  CLUSTER_PARAMETER_GROUP_QUOTA_EXCEEDED_FAULT,
+  CLUSTER_QUOTA_EXCEEDED_FAULT,
+  CLUSTER_SECURITY_GROUP_ALREADY_EXISTS_FAULT,
+  CLUSTER_SECURITY_GROUP_NOT_FOUND_FAULT,
+  CLUSTER_SECURITY_GROUP_QUOTA_EXCEEDED_FAULT,
+  CLUSTER_SNAPSHOT_ALREADY_EXISTS_FAULT,
+  CLUSTER_SNAPSHOT_NOT_FOUND_FAULT,
+  CLUSTER_SNAPSHOT_QUOTA_EXCEEDED_FAULT,
+  CLUSTER_SUBNET_GROUP_ALREADY_EXISTS_FAULT,
+  CLUSTER_SUBNET_GROUP_NOT_FOUND_FAULT,
+  CLUSTER_SUBNET_GROUP_QUOTA_EXCEEDED_FAULT,
+  CLUSTER_SUBNET_QUOTA_EXCEEDED_FAULT,
+  COPY_TO_REGION_DISABLED_FAULT,
+  DEPENDENT_SERVICE_REQUEST_THROTTLING_FAULT,
+  DEPENDENT_SERVICE_UNAVAILABLE_FAULT,
+  EVENT_SUBSCRIPTION_QUOTA_EXCEEDED_FAULT,
+  HSM_CLIENT_CERTIFICATE_ALREADY_EXISTS_FAULT,
+  HSM_CLIENT_CERTIFICATE_NOT_FOUND_FAULT,
+  HSM_CLIENT_CERTIFICATE_QUOTA_EXCEEDED_FAULT,
+  HSM_CONFIGURATION_ALREADY_EXISTS_FAULT,
+  HSM_CONFIGURATION_NOT_FOUND_FAULT,
+  HSM_CONFIGURATION_QUOTA_EXCEEDED_FAULT,
+  INCOMPATIBLE_ORDERABLE_OPTIONS,
+  INSUFFICIENT_CLUSTER_CAPACITY_FAULT,
+  INSUFFICIENT_S3_BUCKET_POLICY_FAULT,
+  INVALID_CLUSTER_PARAMETER_GROUP_STATE_FAULT,
+  INVALID_CLUSTER_SECURITY_GROUP_STATE_FAULT,
+  INVALID_CLUSTER_SNAPSHOT_SCHEDULE_STATE_FAULT,
+  INVALID_CLUSTER_SNAPSHOT_STATE_FAULT,
+  INVALID_CLUSTER_STATE_FAULT,
+  INVALID_CLUSTER_SUBNET_GROUP_STATE_FAULT,
+  INVALID_CLUSTER_SUBNET_STATE_FAULT,
+  INVALID_CLUSTER_TRACK_FAULT,
+  INVALID_ELASTIC_IP_FAULT,
+  INVALID_HSM_CLIENT_CERTIFICATE_STATE_FAULT,
+  INVALID_HSM_CONFIGURATION_STATE_FAULT,
+  INVALID_RESERVED_NODE_STATE_FAULT,
+  INVALID_RESTORE_FAULT,
+  INVALID_RETENTION_PERIOD_FAULT,
+  INVALID_S3_BUCKET_NAME_FAULT,
+  INVALID_S3_KEY_PREFIX_FAULT,
+  INVALID_SCHEDULED_ACTION_FAULT,
+  INVALID_SCHEDULE_FAULT,
+  INVALID_SNAPSHOT_COPY_GRANT_STATE_FAULT,
+  INVALID_SUBNET,
+  INVALID_SUBSCRIPTION_STATE_FAULT,
+  INVALID_TABLE_RESTORE_ARGUMENT_FAULT,
+  INVALID_TAG_FAULT,
+  INVALID_USAGE_LIMIT_FAULT,
+  INVALID_V_P_C_NETWORK_STATE_FAULT,
+  IN_PROGRESS_TABLE_RESTORE_QUOTA_EXCEEDED_FAULT,
+  LIMIT_EXCEEDED_FAULT,
+  NUMBER_OF_NODES_PER_CLUSTER_LIMIT_EXCEEDED_FAULT,
+  NUMBER_OF_NODES_QUOTA_EXCEEDED_FAULT,
+  RESERVED_NODE_ALREADY_EXISTS_FAULT,
+  RESERVED_NODE_ALREADY_MIGRATED_FAULT,
+  RESERVED_NODE_NOT_FOUND_FAULT,
+  RESERVED_NODE_OFFERING_NOT_FOUND_FAULT,
+  RESERVED_NODE_QUOTA_EXCEEDED_FAULT,
+  RESIZE_NOT_FOUND_FAULT,
+  RESOURCE_NOT_FOUND_FAULT,
+  SCHEDULED_ACTION_ALREADY_EXISTS_FAULT,
+  SCHEDULED_ACTION_NOT_FOUND_FAULT,
+  SCHEDULED_ACTION_QUOTA_EXCEEDED_FAULT,
+  SCHEDULED_ACTION_TYPE_UNSUPPORTED_FAULT,
+  SCHEDULE_DEFINITION_TYPE_UNSUPPORTED_FAULT,
+  SNAPSHOT_COPY_ALREADY_DISABLED_FAULT,
+  SNAPSHOT_COPY_ALREADY_ENABLED_FAULT,
+  SNAPSHOT_COPY_DISABLED_FAULT,
+  SNAPSHOT_COPY_GRANT_ALREADY_EXISTS_FAULT,
+  SNAPSHOT_COPY_GRANT_NOT_FOUND_FAULT,
+  SNAPSHOT_COPY_GRANT_QUOTA_EXCEEDED_FAULT,
+  SNAPSHOT_SCHEDULE_ALREADY_EXISTS_FAULT,
+  SNAPSHOT_SCHEDULE_NOT_FOUND_FAULT,
+  SNAPSHOT_SCHEDULE_QUOTA_EXCEEDED_FAULT,
+  SNAPSHOT_SCHEDULE_UPDATE_IN_PROGRESS_FAULT,
+  SOURCE_NOT_FOUND_FAULT,
+  SUBNET_ALREADY_IN_USE,
+  SUBSCRIPTION_ALREADY_EXIST_FAULT,
+  SUBSCRIPTION_CATEGORY_NOT_FOUND_FAULT,
+  SUBSCRIPTION_EVENT_ID_NOT_FOUND_FAULT,
+  SUBSCRIPTION_NOT_FOUND_FAULT,
+  SUBSCRIPTION_SEVERITY_NOT_FOUND_FAULT,
+  S_N_S_INVALID_TOPIC_FAULT,
+  S_N_S_NO_AUTHORIZATION_FAULT,
+  S_N_S_TOPIC_ARN_NOT_FOUND_FAULT,
+  TABLE_LIMIT_EXCEEDED_FAULT,
+  TABLE_RESTORE_NOT_FOUND_FAULT,
+  TAG_LIMIT_EXCEEDED_FAULT,
+  UNAUTHORIZED_OPERATION,
+  UNKNOWN_SNAPSHOT_COPY_REGION_FAULT,
+  UNSUPPORTED_OPERATION_FAULT,
+  UNSUPPORTED_OPTION_FAULT,
+  USAGE_LIMIT_ALREADY_EXISTS_FAULT,
+  USAGE_LIMIT_NOT_FOUND_FAULT
+};
+
+class AWS_REDSHIFT_API RedshiftError : public Aws::Client::AWSError<RedshiftErrors>
+{
+public:
+  RedshiftError() {}
+  RedshiftError(const Aws::Client::AWSError<Aws::Client::CoreErrors>& rhs) : Aws::Client::AWSError<RedshiftErrors>(rhs) {}
+  RedshiftError(Aws::Client::AWSError<Aws::Client::CoreErrors>&& rhs) : Aws::Client::AWSError<RedshiftErrors>(rhs) {}
+  RedshiftError(const Aws::Client::AWSError<RedshiftErrors>& rhs) : Aws::Client::AWSError<RedshiftErrors>(rhs) {}
+  RedshiftError(Aws::Client::AWSError<RedshiftErrors>&& rhs) : Aws::Client::AWSError<RedshiftErrors>(rhs) {}
+
+  template <typename T>
+  T GetModeledError();
+};
+
+namespace RedshiftErrorMapper
+{
+  AWS_REDSHIFT_API Aws::Client::AWSError<Aws::Client::CoreErrors> GetErrorForName(const char* errorName);
+}
+
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/RedshiftRequest.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/redshift/Redshift_EXPORTS.h>
+#include <aws/core/AmazonSerializableWebServiceRequest.h>
+#include <aws/core/utils/UnreferencedParam.h>
+#include <aws/core/http/HttpRequest.h>
+
+namespace Aws
+{
+namespace Redshift
+{
+  class AWS_REDSHIFT_API RedshiftRequest : public Aws::AmazonSerializableWebServiceRequest
+  {
+  public:
+    virtual ~RedshiftRequest () {}
+
+    void AddParametersToRequest(Aws::Http::HttpRequest& httpRequest) const { AWS_UNREFERENCED_PARAM(httpRequest); }
+
+    inline Aws::Http::HeaderValueCollection GetHeaders() const override
+    {
+      auto headers = GetRequestSpecificHeaders();
+
+      if(headers.size() == 0 || (headers.size() > 0 && headers.count(Aws::Http::CONTENT_TYPE_HEADER) == 0))
+      {
+        headers.emplace(Aws::Http::HeaderValuePair(Aws::Http::CONTENT_TYPE_HEADER, Aws::FORM_CONTENT_TYPE ));
+      }
+      headers.emplace(Aws::Http::HeaderValuePair(Aws::Http::API_VERSION_HEADER, "2012-12-01"));
+      return headers;
+    }
+
+  protected:
+    virtual Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const { return Aws::Http::HeaderValueCollection(); }
+
+  };
+
+
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/Redshift_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_REDSHIFT_EXPORTS
+            #define AWS_REDSHIFT_API __declspec(dllexport)
+        #else
+            #define AWS_REDSHIFT_API __declspec(dllimport)
+        #endif /* AWS_REDSHIFT_EXPORTS */
+    #else
+        #define AWS_REDSHIFT_API
+    #endif // USE_IMPORT_EXPORT
+#else // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)
+    #define AWS_REDSHIFT_API
+#endif // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/AcceptReservedNodeExchangeRequest.h

@@ -0,0 +1,155 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_REDSHIFT_API AcceptReservedNodeExchangeRequest : public RedshiftRequest
+  {
+  public:
+    AcceptReservedNodeExchangeRequest();
+
+    // 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 "AcceptReservedNodeExchange"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>A string representing the node identifier of the DC1 Reserved Node to be
+     * exchanged.</p>
+     */
+    inline const Aws::String& GetReservedNodeId() const{ return m_reservedNodeId; }
+
+    /**
+     * <p>A string representing the node identifier of the DC1 Reserved Node to be
+     * exchanged.</p>
+     */
+    inline bool ReservedNodeIdHasBeenSet() const { return m_reservedNodeIdHasBeenSet; }
+
+    /**
+     * <p>A string representing the node identifier of the DC1 Reserved Node to be
+     * exchanged.</p>
+     */
+    inline void SetReservedNodeId(const Aws::String& value) { m_reservedNodeIdHasBeenSet = true; m_reservedNodeId = value; }
+
+    /**
+     * <p>A string representing the node identifier of the DC1 Reserved Node to be
+     * exchanged.</p>
+     */
+    inline void SetReservedNodeId(Aws::String&& value) { m_reservedNodeIdHasBeenSet = true; m_reservedNodeId = std::move(value); }
+
+    /**
+     * <p>A string representing the node identifier of the DC1 Reserved Node to be
+     * exchanged.</p>
+     */
+    inline void SetReservedNodeId(const char* value) { m_reservedNodeIdHasBeenSet = true; m_reservedNodeId.assign(value); }
+
+    /**
+     * <p>A string representing the node identifier of the DC1 Reserved Node to be
+     * exchanged.</p>
+     */
+    inline AcceptReservedNodeExchangeRequest& WithReservedNodeId(const Aws::String& value) { SetReservedNodeId(value); return *this;}
+
+    /**
+     * <p>A string representing the node identifier of the DC1 Reserved Node to be
+     * exchanged.</p>
+     */
+    inline AcceptReservedNodeExchangeRequest& WithReservedNodeId(Aws::String&& value) { SetReservedNodeId(std::move(value)); return *this;}
+
+    /**
+     * <p>A string representing the node identifier of the DC1 Reserved Node to be
+     * exchanged.</p>
+     */
+    inline AcceptReservedNodeExchangeRequest& WithReservedNodeId(const char* value) { SetReservedNodeId(value); return *this;}
+
+
+    /**
+     * <p>The unique identifier of the DC2 Reserved Node offering to be used for the
+     * exchange. You can obtain the value for the parameter by calling
+     * <a>GetReservedNodeExchangeOfferings</a> </p>
+     */
+    inline const Aws::String& GetTargetReservedNodeOfferingId() const{ return m_targetReservedNodeOfferingId; }
+
+    /**
+     * <p>The unique identifier of the DC2 Reserved Node offering to be used for the
+     * exchange. You can obtain the value for the parameter by calling
+     * <a>GetReservedNodeExchangeOfferings</a> </p>
+     */
+    inline bool TargetReservedNodeOfferingIdHasBeenSet() const { return m_targetReservedNodeOfferingIdHasBeenSet; }
+
+    /**
+     * <p>The unique identifier of the DC2 Reserved Node offering to be used for the
+     * exchange. You can obtain the value for the parameter by calling
+     * <a>GetReservedNodeExchangeOfferings</a> </p>
+     */
+    inline void SetTargetReservedNodeOfferingId(const Aws::String& value) { m_targetReservedNodeOfferingIdHasBeenSet = true; m_targetReservedNodeOfferingId = value; }
+
+    /**
+     * <p>The unique identifier of the DC2 Reserved Node offering to be used for the
+     * exchange. You can obtain the value for the parameter by calling
+     * <a>GetReservedNodeExchangeOfferings</a> </p>
+     */
+    inline void SetTargetReservedNodeOfferingId(Aws::String&& value) { m_targetReservedNodeOfferingIdHasBeenSet = true; m_targetReservedNodeOfferingId = std::move(value); }
+
+    /**
+     * <p>The unique identifier of the DC2 Reserved Node offering to be used for the
+     * exchange. You can obtain the value for the parameter by calling
+     * <a>GetReservedNodeExchangeOfferings</a> </p>
+     */
+    inline void SetTargetReservedNodeOfferingId(const char* value) { m_targetReservedNodeOfferingIdHasBeenSet = true; m_targetReservedNodeOfferingId.assign(value); }
+
+    /**
+     * <p>The unique identifier of the DC2 Reserved Node offering to be used for the
+     * exchange. You can obtain the value for the parameter by calling
+     * <a>GetReservedNodeExchangeOfferings</a> </p>
+     */
+    inline AcceptReservedNodeExchangeRequest& WithTargetReservedNodeOfferingId(const Aws::String& value) { SetTargetReservedNodeOfferingId(value); return *this;}
+
+    /**
+     * <p>The unique identifier of the DC2 Reserved Node offering to be used for the
+     * exchange. You can obtain the value for the parameter by calling
+     * <a>GetReservedNodeExchangeOfferings</a> </p>
+     */
+    inline AcceptReservedNodeExchangeRequest& WithTargetReservedNodeOfferingId(Aws::String&& value) { SetTargetReservedNodeOfferingId(std::move(value)); return *this;}
+
+    /**
+     * <p>The unique identifier of the DC2 Reserved Node offering to be used for the
+     * exchange. You can obtain the value for the parameter by calling
+     * <a>GetReservedNodeExchangeOfferings</a> </p>
+     */
+    inline AcceptReservedNodeExchangeRequest& WithTargetReservedNodeOfferingId(const char* value) { SetTargetReservedNodeOfferingId(value); return *this;}
+
+  private:
+
+    Aws::String m_reservedNodeId;
+    bool m_reservedNodeIdHasBeenSet;
+
+    Aws::String m_targetReservedNodeOfferingId;
+    bool m_targetReservedNodeOfferingIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/AcceptReservedNodeExchangeResult.h

@@ -0,0 +1,86 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/model/ReservedNode.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  class AWS_REDSHIFT_API AcceptReservedNodeExchangeResult
+  {
+  public:
+    AcceptReservedNodeExchangeResult();
+    AcceptReservedNodeExchangeResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    AcceptReservedNodeExchangeResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    /**
+     * <p/>
+     */
+    inline const ReservedNode& GetExchangedReservedNode() const{ return m_exchangedReservedNode; }
+
+    /**
+     * <p/>
+     */
+    inline void SetExchangedReservedNode(const ReservedNode& value) { m_exchangedReservedNode = value; }
+
+    /**
+     * <p/>
+     */
+    inline void SetExchangedReservedNode(ReservedNode&& value) { m_exchangedReservedNode = std::move(value); }
+
+    /**
+     * <p/>
+     */
+    inline AcceptReservedNodeExchangeResult& WithExchangedReservedNode(const ReservedNode& value) { SetExchangedReservedNode(value); return *this;}
+
+    /**
+     * <p/>
+     */
+    inline AcceptReservedNodeExchangeResult& WithExchangedReservedNode(ReservedNode&& value) { SetExchangedReservedNode(std::move(value)); return *this;}
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline AcceptReservedNodeExchangeResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline AcceptReservedNodeExchangeResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    ReservedNode m_exchangedReservedNode;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/AccountAttribute.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/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/AttributeValueTarget.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p>A name value pair that describes an aspect of an account. </p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/AccountAttribute">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API AccountAttribute
+  {
+  public:
+    AccountAttribute();
+    AccountAttribute(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AccountAttribute& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    /**
+     * <p>The name of the attribute.</p>
+     */
+    inline const Aws::String& GetAttributeName() const{ return m_attributeName; }
+
+    /**
+     * <p>The name of the attribute.</p>
+     */
+    inline bool AttributeNameHasBeenSet() const { return m_attributeNameHasBeenSet; }
+
+    /**
+     * <p>The name of the attribute.</p>
+     */
+    inline void SetAttributeName(const Aws::String& value) { m_attributeNameHasBeenSet = true; m_attributeName = value; }
+
+    /**
+     * <p>The name of the attribute.</p>
+     */
+    inline void SetAttributeName(Aws::String&& value) { m_attributeNameHasBeenSet = true; m_attributeName = std::move(value); }
+
+    /**
+     * <p>The name of the attribute.</p>
+     */
+    inline void SetAttributeName(const char* value) { m_attributeNameHasBeenSet = true; m_attributeName.assign(value); }
+
+    /**
+     * <p>The name of the attribute.</p>
+     */
+    inline AccountAttribute& WithAttributeName(const Aws::String& value) { SetAttributeName(value); return *this;}
+
+    /**
+     * <p>The name of the attribute.</p>
+     */
+    inline AccountAttribute& WithAttributeName(Aws::String&& value) { SetAttributeName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the attribute.</p>
+     */
+    inline AccountAttribute& WithAttributeName(const char* value) { SetAttributeName(value); return *this;}
+
+
+    /**
+     * <p>A list of attribute values.</p>
+     */
+    inline const Aws::Vector<AttributeValueTarget>& GetAttributeValues() const{ return m_attributeValues; }
+
+    /**
+     * <p>A list of attribute values.</p>
+     */
+    inline bool AttributeValuesHasBeenSet() const { return m_attributeValuesHasBeenSet; }
+
+    /**
+     * <p>A list of attribute values.</p>
+     */
+    inline void SetAttributeValues(const Aws::Vector<AttributeValueTarget>& value) { m_attributeValuesHasBeenSet = true; m_attributeValues = value; }
+
+    /**
+     * <p>A list of attribute values.</p>
+     */
+    inline void SetAttributeValues(Aws::Vector<AttributeValueTarget>&& value) { m_attributeValuesHasBeenSet = true; m_attributeValues = std::move(value); }
+
+    /**
+     * <p>A list of attribute values.</p>
+     */
+    inline AccountAttribute& WithAttributeValues(const Aws::Vector<AttributeValueTarget>& value) { SetAttributeValues(value); return *this;}
+
+    /**
+     * <p>A list of attribute values.</p>
+     */
+    inline AccountAttribute& WithAttributeValues(Aws::Vector<AttributeValueTarget>&& value) { SetAttributeValues(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of attribute values.</p>
+     */
+    inline AccountAttribute& AddAttributeValues(const AttributeValueTarget& value) { m_attributeValuesHasBeenSet = true; m_attributeValues.push_back(value); return *this; }
+
+    /**
+     * <p>A list of attribute values.</p>
+     */
+    inline AccountAttribute& AddAttributeValues(AttributeValueTarget&& value) { m_attributeValuesHasBeenSet = true; m_attributeValues.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_attributeName;
+    bool m_attributeNameHasBeenSet;
+
+    Aws::Vector<AttributeValueTarget> m_attributeValues;
+    bool m_attributeValuesHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/AccountWithRestoreAccess.h

@@ -0,0 +1,151 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p>Describes an AWS customer account authorized to restore a
+   * snapshot.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/AccountWithRestoreAccess">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API AccountWithRestoreAccess
+  {
+  public:
+    AccountWithRestoreAccess();
+    AccountWithRestoreAccess(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AccountWithRestoreAccess& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    /**
+     * <p>The identifier of an AWS customer account authorized to restore a
+     * snapshot.</p>
+     */
+    inline const Aws::String& GetAccountId() const{ return m_accountId; }
+
+    /**
+     * <p>The identifier of an AWS customer account authorized to restore a
+     * snapshot.</p>
+     */
+    inline bool AccountIdHasBeenSet() const { return m_accountIdHasBeenSet; }
+
+    /**
+     * <p>The identifier of an AWS customer account authorized to restore a
+     * snapshot.</p>
+     */
+    inline void SetAccountId(const Aws::String& value) { m_accountIdHasBeenSet = true; m_accountId = value; }
+
+    /**
+     * <p>The identifier of an AWS customer account authorized to restore a
+     * snapshot.</p>
+     */
+    inline void SetAccountId(Aws::String&& value) { m_accountIdHasBeenSet = true; m_accountId = std::move(value); }
+
+    /**
+     * <p>The identifier of an AWS customer account authorized to restore a
+     * snapshot.</p>
+     */
+    inline void SetAccountId(const char* value) { m_accountIdHasBeenSet = true; m_accountId.assign(value); }
+
+    /**
+     * <p>The identifier of an AWS customer account authorized to restore a
+     * snapshot.</p>
+     */
+    inline AccountWithRestoreAccess& WithAccountId(const Aws::String& value) { SetAccountId(value); return *this;}
+
+    /**
+     * <p>The identifier of an AWS customer account authorized to restore a
+     * snapshot.</p>
+     */
+    inline AccountWithRestoreAccess& WithAccountId(Aws::String&& value) { SetAccountId(std::move(value)); return *this;}
+
+    /**
+     * <p>The identifier of an AWS customer account authorized to restore a
+     * snapshot.</p>
+     */
+    inline AccountWithRestoreAccess& WithAccountId(const char* value) { SetAccountId(value); return *this;}
+
+
+    /**
+     * <p>The identifier of an AWS support account authorized to restore a snapshot.
+     * For AWS support, the identifier is <code>amazon-redshift-support</code>. </p>
+     */
+    inline const Aws::String& GetAccountAlias() const{ return m_accountAlias; }
+
+    /**
+     * <p>The identifier of an AWS support account authorized to restore a snapshot.
+     * For AWS support, the identifier is <code>amazon-redshift-support</code>. </p>
+     */
+    inline bool AccountAliasHasBeenSet() const { return m_accountAliasHasBeenSet; }
+
+    /**
+     * <p>The identifier of an AWS support account authorized to restore a snapshot.
+     * For AWS support, the identifier is <code>amazon-redshift-support</code>. </p>
+     */
+    inline void SetAccountAlias(const Aws::String& value) { m_accountAliasHasBeenSet = true; m_accountAlias = value; }
+
+    /**
+     * <p>The identifier of an AWS support account authorized to restore a snapshot.
+     * For AWS support, the identifier is <code>amazon-redshift-support</code>. </p>
+     */
+    inline void SetAccountAlias(Aws::String&& value) { m_accountAliasHasBeenSet = true; m_accountAlias = std::move(value); }
+
+    /**
+     * <p>The identifier of an AWS support account authorized to restore a snapshot.
+     * For AWS support, the identifier is <code>amazon-redshift-support</code>. </p>
+     */
+    inline void SetAccountAlias(const char* value) { m_accountAliasHasBeenSet = true; m_accountAlias.assign(value); }
+
+    /**
+     * <p>The identifier of an AWS support account authorized to restore a snapshot.
+     * For AWS support, the identifier is <code>amazon-redshift-support</code>. </p>
+     */
+    inline AccountWithRestoreAccess& WithAccountAlias(const Aws::String& value) { SetAccountAlias(value); return *this;}
+
+    /**
+     * <p>The identifier of an AWS support account authorized to restore a snapshot.
+     * For AWS support, the identifier is <code>amazon-redshift-support</code>. </p>
+     */
+    inline AccountWithRestoreAccess& WithAccountAlias(Aws::String&& value) { SetAccountAlias(std::move(value)); return *this;}
+
+    /**
+     * <p>The identifier of an AWS support account authorized to restore a snapshot.
+     * For AWS support, the identifier is <code>amazon-redshift-support</code>. </p>
+     */
+    inline AccountWithRestoreAccess& WithAccountAlias(const char* value) { SetAccountAlias(value); return *this;}
+
+  private:
+
+    Aws::String m_accountId;
+    bool m_accountIdHasBeenSet;
+
+    Aws::String m_accountAlias;
+    bool m_accountAliasHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/ActionType.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/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+  enum class ActionType
+  {
+    NOT_SET,
+    restore_cluster,
+    recommend_node_config,
+    resize_cluster
+  };
+
+namespace ActionTypeMapper
+{
+AWS_REDSHIFT_API ActionType GetActionTypeForName(const Aws::String& name);
+
+AWS_REDSHIFT_API Aws::String GetNameForActionType(ActionType value);
+} // namespace ActionTypeMapper
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/AttributeValueTarget.h

@@ -0,0 +1,90 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p>Describes an attribute value.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/AttributeValueTarget">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API AttributeValueTarget
+  {
+  public:
+    AttributeValueTarget();
+    AttributeValueTarget(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AttributeValueTarget& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    /**
+     * <p>The value of the attribute.</p>
+     */
+    inline const Aws::String& GetAttributeValue() const{ return m_attributeValue; }
+
+    /**
+     * <p>The value of the attribute.</p>
+     */
+    inline bool AttributeValueHasBeenSet() const { return m_attributeValueHasBeenSet; }
+
+    /**
+     * <p>The value of the attribute.</p>
+     */
+    inline void SetAttributeValue(const Aws::String& value) { m_attributeValueHasBeenSet = true; m_attributeValue = value; }
+
+    /**
+     * <p>The value of the attribute.</p>
+     */
+    inline void SetAttributeValue(Aws::String&& value) { m_attributeValueHasBeenSet = true; m_attributeValue = std::move(value); }
+
+    /**
+     * <p>The value of the attribute.</p>
+     */
+    inline void SetAttributeValue(const char* value) { m_attributeValueHasBeenSet = true; m_attributeValue.assign(value); }
+
+    /**
+     * <p>The value of the attribute.</p>
+     */
+    inline AttributeValueTarget& WithAttributeValue(const Aws::String& value) { SetAttributeValue(value); return *this;}
+
+    /**
+     * <p>The value of the attribute.</p>
+     */
+    inline AttributeValueTarget& WithAttributeValue(Aws::String&& value) { SetAttributeValue(std::move(value)); return *this;}
+
+    /**
+     * <p>The value of the attribute.</p>
+     */
+    inline AttributeValueTarget& WithAttributeValue(const char* value) { SetAttributeValue(value); return *this;}
+
+  private:
+
+    Aws::String m_attributeValue;
+    bool m_attributeValueHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/AuthorizeClusterSecurityGroupIngressRequest.h

@@ -0,0 +1,238 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p/><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/AuthorizeClusterSecurityGroupIngressMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API AuthorizeClusterSecurityGroupIngressRequest : public RedshiftRequest
+  {
+  public:
+    AuthorizeClusterSecurityGroupIngressRequest();
+
+    // 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 "AuthorizeClusterSecurityGroupIngress"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The name of the security group to which the ingress rule is added.</p>
+     */
+    inline const Aws::String& GetClusterSecurityGroupName() const{ return m_clusterSecurityGroupName; }
+
+    /**
+     * <p>The name of the security group to which the ingress rule is added.</p>
+     */
+    inline bool ClusterSecurityGroupNameHasBeenSet() const { return m_clusterSecurityGroupNameHasBeenSet; }
+
+    /**
+     * <p>The name of the security group to which the ingress rule is added.</p>
+     */
+    inline void SetClusterSecurityGroupName(const Aws::String& value) { m_clusterSecurityGroupNameHasBeenSet = true; m_clusterSecurityGroupName = value; }
+
+    /**
+     * <p>The name of the security group to which the ingress rule is added.</p>
+     */
+    inline void SetClusterSecurityGroupName(Aws::String&& value) { m_clusterSecurityGroupNameHasBeenSet = true; m_clusterSecurityGroupName = std::move(value); }
+
+    /**
+     * <p>The name of the security group to which the ingress rule is added.</p>
+     */
+    inline void SetClusterSecurityGroupName(const char* value) { m_clusterSecurityGroupNameHasBeenSet = true; m_clusterSecurityGroupName.assign(value); }
+
+    /**
+     * <p>The name of the security group to which the ingress rule is added.</p>
+     */
+    inline AuthorizeClusterSecurityGroupIngressRequest& WithClusterSecurityGroupName(const Aws::String& value) { SetClusterSecurityGroupName(value); return *this;}
+
+    /**
+     * <p>The name of the security group to which the ingress rule is added.</p>
+     */
+    inline AuthorizeClusterSecurityGroupIngressRequest& WithClusterSecurityGroupName(Aws::String&& value) { SetClusterSecurityGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the security group to which the ingress rule is added.</p>
+     */
+    inline AuthorizeClusterSecurityGroupIngressRequest& WithClusterSecurityGroupName(const char* value) { SetClusterSecurityGroupName(value); return *this;}
+
+
+    /**
+     * <p>The IP range to be added the Amazon Redshift security group.</p>
+     */
+    inline const Aws::String& GetCIDRIP() const{ return m_cIDRIP; }
+
+    /**
+     * <p>The IP range to be added the Amazon Redshift security group.</p>
+     */
+    inline bool CIDRIPHasBeenSet() const { return m_cIDRIPHasBeenSet; }
+
+    /**
+     * <p>The IP range to be added the Amazon Redshift security group.</p>
+     */
+    inline void SetCIDRIP(const Aws::String& value) { m_cIDRIPHasBeenSet = true; m_cIDRIP = value; }
+
+    /**
+     * <p>The IP range to be added the Amazon Redshift security group.</p>
+     */
+    inline void SetCIDRIP(Aws::String&& value) { m_cIDRIPHasBeenSet = true; m_cIDRIP = std::move(value); }
+
+    /**
+     * <p>The IP range to be added the Amazon Redshift security group.</p>
+     */
+    inline void SetCIDRIP(const char* value) { m_cIDRIPHasBeenSet = true; m_cIDRIP.assign(value); }
+
+    /**
+     * <p>The IP range to be added the Amazon Redshift security group.</p>
+     */
+    inline AuthorizeClusterSecurityGroupIngressRequest& WithCIDRIP(const Aws::String& value) { SetCIDRIP(value); return *this;}
+
+    /**
+     * <p>The IP range to be added the Amazon Redshift security group.</p>
+     */
+    inline AuthorizeClusterSecurityGroupIngressRequest& WithCIDRIP(Aws::String&& value) { SetCIDRIP(std::move(value)); return *this;}
+
+    /**
+     * <p>The IP range to be added the Amazon Redshift security group.</p>
+     */
+    inline AuthorizeClusterSecurityGroupIngressRequest& WithCIDRIP(const char* value) { SetCIDRIP(value); return *this;}
+
+
+    /**
+     * <p>The EC2 security group to be added the Amazon Redshift security group.</p>
+     */
+    inline const Aws::String& GetEC2SecurityGroupName() const{ return m_eC2SecurityGroupName; }
+
+    /**
+     * <p>The EC2 security group to be added the Amazon Redshift security group.</p>
+     */
+    inline bool EC2SecurityGroupNameHasBeenSet() const { return m_eC2SecurityGroupNameHasBeenSet; }
+
+    /**
+     * <p>The EC2 security group to be added the Amazon Redshift security group.</p>
+     */
+    inline void SetEC2SecurityGroupName(const Aws::String& value) { m_eC2SecurityGroupNameHasBeenSet = true; m_eC2SecurityGroupName = value; }
+
+    /**
+     * <p>The EC2 security group to be added the Amazon Redshift security group.</p>
+     */
+    inline void SetEC2SecurityGroupName(Aws::String&& value) { m_eC2SecurityGroupNameHasBeenSet = true; m_eC2SecurityGroupName = std::move(value); }
+
+    /**
+     * <p>The EC2 security group to be added the Amazon Redshift security group.</p>
+     */
+    inline void SetEC2SecurityGroupName(const char* value) { m_eC2SecurityGroupNameHasBeenSet = true; m_eC2SecurityGroupName.assign(value); }
+
+    /**
+     * <p>The EC2 security group to be added the Amazon Redshift security group.</p>
+     */
+    inline AuthorizeClusterSecurityGroupIngressRequest& WithEC2SecurityGroupName(const Aws::String& value) { SetEC2SecurityGroupName(value); return *this;}
+
+    /**
+     * <p>The EC2 security group to be added the Amazon Redshift security group.</p>
+     */
+    inline AuthorizeClusterSecurityGroupIngressRequest& WithEC2SecurityGroupName(Aws::String&& value) { SetEC2SecurityGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The EC2 security group to be added the Amazon Redshift security group.</p>
+     */
+    inline AuthorizeClusterSecurityGroupIngressRequest& WithEC2SecurityGroupName(const char* value) { SetEC2SecurityGroupName(value); return *this;}
+
+
+    /**
+     * <p>The AWS account number of the owner of the security group specified by the
+     * <i>EC2SecurityGroupName</i> parameter. The AWS Access Key ID is not an
+     * acceptable value. </p> <p>Example: <code>111122223333</code> </p>
+     */
+    inline const Aws::String& GetEC2SecurityGroupOwnerId() const{ return m_eC2SecurityGroupOwnerId; }
+
+    /**
+     * <p>The AWS account number of the owner of the security group specified by the
+     * <i>EC2SecurityGroupName</i> parameter. The AWS Access Key ID is not an
+     * acceptable value. </p> <p>Example: <code>111122223333</code> </p>
+     */
+    inline bool EC2SecurityGroupOwnerIdHasBeenSet() const { return m_eC2SecurityGroupOwnerIdHasBeenSet; }
+
+    /**
+     * <p>The AWS account number of the owner of the security group specified by the
+     * <i>EC2SecurityGroupName</i> parameter. The AWS Access Key ID is not an
+     * acceptable value. </p> <p>Example: <code>111122223333</code> </p>
+     */
+    inline void SetEC2SecurityGroupOwnerId(const Aws::String& value) { m_eC2SecurityGroupOwnerIdHasBeenSet = true; m_eC2SecurityGroupOwnerId = value; }
+
+    /**
+     * <p>The AWS account number of the owner of the security group specified by the
+     * <i>EC2SecurityGroupName</i> parameter. The AWS Access Key ID is not an
+     * acceptable value. </p> <p>Example: <code>111122223333</code> </p>
+     */
+    inline void SetEC2SecurityGroupOwnerId(Aws::String&& value) { m_eC2SecurityGroupOwnerIdHasBeenSet = true; m_eC2SecurityGroupOwnerId = std::move(value); }
+
+    /**
+     * <p>The AWS account number of the owner of the security group specified by the
+     * <i>EC2SecurityGroupName</i> parameter. The AWS Access Key ID is not an
+     * acceptable value. </p> <p>Example: <code>111122223333</code> </p>
+     */
+    inline void SetEC2SecurityGroupOwnerId(const char* value) { m_eC2SecurityGroupOwnerIdHasBeenSet = true; m_eC2SecurityGroupOwnerId.assign(value); }
+
+    /**
+     * <p>The AWS account number of the owner of the security group specified by the
+     * <i>EC2SecurityGroupName</i> parameter. The AWS Access Key ID is not an
+     * acceptable value. </p> <p>Example: <code>111122223333</code> </p>
+     */
+    inline AuthorizeClusterSecurityGroupIngressRequest& WithEC2SecurityGroupOwnerId(const Aws::String& value) { SetEC2SecurityGroupOwnerId(value); return *this;}
+
+    /**
+     * <p>The AWS account number of the owner of the security group specified by the
+     * <i>EC2SecurityGroupName</i> parameter. The AWS Access Key ID is not an
+     * acceptable value. </p> <p>Example: <code>111122223333</code> </p>
+     */
+    inline AuthorizeClusterSecurityGroupIngressRequest& WithEC2SecurityGroupOwnerId(Aws::String&& value) { SetEC2SecurityGroupOwnerId(std::move(value)); return *this;}
+
+    /**
+     * <p>The AWS account number of the owner of the security group specified by the
+     * <i>EC2SecurityGroupName</i> parameter. The AWS Access Key ID is not an
+     * acceptable value. </p> <p>Example: <code>111122223333</code> </p>
+     */
+    inline AuthorizeClusterSecurityGroupIngressRequest& WithEC2SecurityGroupOwnerId(const char* value) { SetEC2SecurityGroupOwnerId(value); return *this;}
+
+  private:
+
+    Aws::String m_clusterSecurityGroupName;
+    bool m_clusterSecurityGroupNameHasBeenSet;
+
+    Aws::String m_cIDRIP;
+    bool m_cIDRIPHasBeenSet;
+
+    Aws::String m_eC2SecurityGroupName;
+    bool m_eC2SecurityGroupNameHasBeenSet;
+
+    Aws::String m_eC2SecurityGroupOwnerId;
+    bool m_eC2SecurityGroupOwnerIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/AuthorizeClusterSecurityGroupIngressResult.h

@@ -0,0 +1,76 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/model/ClusterSecurityGroup.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  class AWS_REDSHIFT_API AuthorizeClusterSecurityGroupIngressResult
+  {
+  public:
+    AuthorizeClusterSecurityGroupIngressResult();
+    AuthorizeClusterSecurityGroupIngressResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    AuthorizeClusterSecurityGroupIngressResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    
+    inline const ClusterSecurityGroup& GetClusterSecurityGroup() const{ return m_clusterSecurityGroup; }
+
+    
+    inline void SetClusterSecurityGroup(const ClusterSecurityGroup& value) { m_clusterSecurityGroup = value; }
+
+    
+    inline void SetClusterSecurityGroup(ClusterSecurityGroup&& value) { m_clusterSecurityGroup = std::move(value); }
+
+    
+    inline AuthorizeClusterSecurityGroupIngressResult& WithClusterSecurityGroup(const ClusterSecurityGroup& value) { SetClusterSecurityGroup(value); return *this;}
+
+    
+    inline AuthorizeClusterSecurityGroupIngressResult& WithClusterSecurityGroup(ClusterSecurityGroup&& value) { SetClusterSecurityGroup(std::move(value)); return *this;}
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline AuthorizeClusterSecurityGroupIngressResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline AuthorizeClusterSecurityGroupIngressResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    ClusterSecurityGroup m_clusterSecurityGroup;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/AuthorizeSnapshotAccessRequest.h

@@ -0,0 +1,210 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p/><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/AuthorizeSnapshotAccessMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API AuthorizeSnapshotAccessRequest : public RedshiftRequest
+  {
+  public:
+    AuthorizeSnapshotAccessRequest();
+
+    // 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 "AuthorizeSnapshotAccess"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The identifier of the snapshot the account is authorized to restore.</p>
+     */
+    inline const Aws::String& GetSnapshotIdentifier() const{ return m_snapshotIdentifier; }
+
+    /**
+     * <p>The identifier of the snapshot the account is authorized to restore.</p>
+     */
+    inline bool SnapshotIdentifierHasBeenSet() const { return m_snapshotIdentifierHasBeenSet; }
+
+    /**
+     * <p>The identifier of the snapshot the account is authorized to restore.</p>
+     */
+    inline void SetSnapshotIdentifier(const Aws::String& value) { m_snapshotIdentifierHasBeenSet = true; m_snapshotIdentifier = value; }
+
+    /**
+     * <p>The identifier of the snapshot the account is authorized to restore.</p>
+     */
+    inline void SetSnapshotIdentifier(Aws::String&& value) { m_snapshotIdentifierHasBeenSet = true; m_snapshotIdentifier = std::move(value); }
+
+    /**
+     * <p>The identifier of the snapshot the account is authorized to restore.</p>
+     */
+    inline void SetSnapshotIdentifier(const char* value) { m_snapshotIdentifierHasBeenSet = true; m_snapshotIdentifier.assign(value); }
+
+    /**
+     * <p>The identifier of the snapshot the account is authorized to restore.</p>
+     */
+    inline AuthorizeSnapshotAccessRequest& WithSnapshotIdentifier(const Aws::String& value) { SetSnapshotIdentifier(value); return *this;}
+
+    /**
+     * <p>The identifier of the snapshot the account is authorized to restore.</p>
+     */
+    inline AuthorizeSnapshotAccessRequest& WithSnapshotIdentifier(Aws::String&& value) { SetSnapshotIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>The identifier of the snapshot the account is authorized to restore.</p>
+     */
+    inline AuthorizeSnapshotAccessRequest& WithSnapshotIdentifier(const char* value) { SetSnapshotIdentifier(value); return *this;}
+
+
+    /**
+     * <p>The identifier of the cluster the snapshot was created from. This parameter
+     * is required if your IAM user has a policy containing a snapshot resource element
+     * that specifies anything other than * for the cluster name.</p>
+     */
+    inline const Aws::String& GetSnapshotClusterIdentifier() const{ return m_snapshotClusterIdentifier; }
+
+    /**
+     * <p>The identifier of the cluster the snapshot was created from. This parameter
+     * is required if your IAM user has a policy containing a snapshot resource element
+     * that specifies anything other than * for the cluster name.</p>
+     */
+    inline bool SnapshotClusterIdentifierHasBeenSet() const { return m_snapshotClusterIdentifierHasBeenSet; }
+
+    /**
+     * <p>The identifier of the cluster the snapshot was created from. This parameter
+     * is required if your IAM user has a policy containing a snapshot resource element
+     * that specifies anything other than * for the cluster name.</p>
+     */
+    inline void SetSnapshotClusterIdentifier(const Aws::String& value) { m_snapshotClusterIdentifierHasBeenSet = true; m_snapshotClusterIdentifier = value; }
+
+    /**
+     * <p>The identifier of the cluster the snapshot was created from. This parameter
+     * is required if your IAM user has a policy containing a snapshot resource element
+     * that specifies anything other than * for the cluster name.</p>
+     */
+    inline void SetSnapshotClusterIdentifier(Aws::String&& value) { m_snapshotClusterIdentifierHasBeenSet = true; m_snapshotClusterIdentifier = std::move(value); }
+
+    /**
+     * <p>The identifier of the cluster the snapshot was created from. This parameter
+     * is required if your IAM user has a policy containing a snapshot resource element
+     * that specifies anything other than * for the cluster name.</p>
+     */
+    inline void SetSnapshotClusterIdentifier(const char* value) { m_snapshotClusterIdentifierHasBeenSet = true; m_snapshotClusterIdentifier.assign(value); }
+
+    /**
+     * <p>The identifier of the cluster the snapshot was created from. This parameter
+     * is required if your IAM user has a policy containing a snapshot resource element
+     * that specifies anything other than * for the cluster name.</p>
+     */
+    inline AuthorizeSnapshotAccessRequest& WithSnapshotClusterIdentifier(const Aws::String& value) { SetSnapshotClusterIdentifier(value); return *this;}
+
+    /**
+     * <p>The identifier of the cluster the snapshot was created from. This parameter
+     * is required if your IAM user has a policy containing a snapshot resource element
+     * that specifies anything other than * for the cluster name.</p>
+     */
+    inline AuthorizeSnapshotAccessRequest& WithSnapshotClusterIdentifier(Aws::String&& value) { SetSnapshotClusterIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>The identifier of the cluster the snapshot was created from. This parameter
+     * is required if your IAM user has a policy containing a snapshot resource element
+     * that specifies anything other than * for the cluster name.</p>
+     */
+    inline AuthorizeSnapshotAccessRequest& WithSnapshotClusterIdentifier(const char* value) { SetSnapshotClusterIdentifier(value); return *this;}
+
+
+    /**
+     * <p>The identifier of the AWS customer account authorized to restore the
+     * specified snapshot.</p> <p>To share a snapshot with AWS support, specify
+     * amazon-redshift-support.</p>
+     */
+    inline const Aws::String& GetAccountWithRestoreAccess() const{ return m_accountWithRestoreAccess; }
+
+    /**
+     * <p>The identifier of the AWS customer account authorized to restore the
+     * specified snapshot.</p> <p>To share a snapshot with AWS support, specify
+     * amazon-redshift-support.</p>
+     */
+    inline bool AccountWithRestoreAccessHasBeenSet() const { return m_accountWithRestoreAccessHasBeenSet; }
+
+    /**
+     * <p>The identifier of the AWS customer account authorized to restore the
+     * specified snapshot.</p> <p>To share a snapshot with AWS support, specify
+     * amazon-redshift-support.</p>
+     */
+    inline void SetAccountWithRestoreAccess(const Aws::String& value) { m_accountWithRestoreAccessHasBeenSet = true; m_accountWithRestoreAccess = value; }
+
+    /**
+     * <p>The identifier of the AWS customer account authorized to restore the
+     * specified snapshot.</p> <p>To share a snapshot with AWS support, specify
+     * amazon-redshift-support.</p>
+     */
+    inline void SetAccountWithRestoreAccess(Aws::String&& value) { m_accountWithRestoreAccessHasBeenSet = true; m_accountWithRestoreAccess = std::move(value); }
+
+    /**
+     * <p>The identifier of the AWS customer account authorized to restore the
+     * specified snapshot.</p> <p>To share a snapshot with AWS support, specify
+     * amazon-redshift-support.</p>
+     */
+    inline void SetAccountWithRestoreAccess(const char* value) { m_accountWithRestoreAccessHasBeenSet = true; m_accountWithRestoreAccess.assign(value); }
+
+    /**
+     * <p>The identifier of the AWS customer account authorized to restore the
+     * specified snapshot.</p> <p>To share a snapshot with AWS support, specify
+     * amazon-redshift-support.</p>
+     */
+    inline AuthorizeSnapshotAccessRequest& WithAccountWithRestoreAccess(const Aws::String& value) { SetAccountWithRestoreAccess(value); return *this;}
+
+    /**
+     * <p>The identifier of the AWS customer account authorized to restore the
+     * specified snapshot.</p> <p>To share a snapshot with AWS support, specify
+     * amazon-redshift-support.</p>
+     */
+    inline AuthorizeSnapshotAccessRequest& WithAccountWithRestoreAccess(Aws::String&& value) { SetAccountWithRestoreAccess(std::move(value)); return *this;}
+
+    /**
+     * <p>The identifier of the AWS customer account authorized to restore the
+     * specified snapshot.</p> <p>To share a snapshot with AWS support, specify
+     * amazon-redshift-support.</p>
+     */
+    inline AuthorizeSnapshotAccessRequest& WithAccountWithRestoreAccess(const char* value) { SetAccountWithRestoreAccess(value); return *this;}
+
+  private:
+
+    Aws::String m_snapshotIdentifier;
+    bool m_snapshotIdentifierHasBeenSet;
+
+    Aws::String m_snapshotClusterIdentifier;
+    bool m_snapshotClusterIdentifierHasBeenSet;
+
+    Aws::String m_accountWithRestoreAccess;
+    bool m_accountWithRestoreAccessHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/AuthorizeSnapshotAccessResult.h

@@ -0,0 +1,76 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/model/Snapshot.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  class AWS_REDSHIFT_API AuthorizeSnapshotAccessResult
+  {
+  public:
+    AuthorizeSnapshotAccessResult();
+    AuthorizeSnapshotAccessResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    AuthorizeSnapshotAccessResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    
+    inline const Snapshot& GetSnapshot() const{ return m_snapshot; }
+
+    
+    inline void SetSnapshot(const Snapshot& value) { m_snapshot = value; }
+
+    
+    inline void SetSnapshot(Snapshot&& value) { m_snapshot = std::move(value); }
+
+    
+    inline AuthorizeSnapshotAccessResult& WithSnapshot(const Snapshot& value) { SetSnapshot(value); return *this;}
+
+    
+    inline AuthorizeSnapshotAccessResult& WithSnapshot(Snapshot&& value) { SetSnapshot(std::move(value)); return *this;}
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline AuthorizeSnapshotAccessResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline AuthorizeSnapshotAccessResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    Snapshot m_snapshot;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/AvailabilityZone.h

@@ -0,0 +1,136 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/SupportedPlatform.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p>Describes an availability zone.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/AvailabilityZone">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API AvailabilityZone
+  {
+  public:
+    AvailabilityZone();
+    AvailabilityZone(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AvailabilityZone& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    /**
+     * <p>The name of the availability zone.</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>The name of the availability zone.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>The name of the availability zone.</p>
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>The name of the availability zone.</p>
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>The name of the availability zone.</p>
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * <p>The name of the availability zone.</p>
+     */
+    inline AvailabilityZone& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>The name of the availability zone.</p>
+     */
+    inline AvailabilityZone& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the availability zone.</p>
+     */
+    inline AvailabilityZone& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * <p/>
+     */
+    inline const Aws::Vector<SupportedPlatform>& GetSupportedPlatforms() const{ return m_supportedPlatforms; }
+
+    /**
+     * <p/>
+     */
+    inline bool SupportedPlatformsHasBeenSet() const { return m_supportedPlatformsHasBeenSet; }
+
+    /**
+     * <p/>
+     */
+    inline void SetSupportedPlatforms(const Aws::Vector<SupportedPlatform>& value) { m_supportedPlatformsHasBeenSet = true; m_supportedPlatforms = value; }
+
+    /**
+     * <p/>
+     */
+    inline void SetSupportedPlatforms(Aws::Vector<SupportedPlatform>&& value) { m_supportedPlatformsHasBeenSet = true; m_supportedPlatforms = std::move(value); }
+
+    /**
+     * <p/>
+     */
+    inline AvailabilityZone& WithSupportedPlatforms(const Aws::Vector<SupportedPlatform>& value) { SetSupportedPlatforms(value); return *this;}
+
+    /**
+     * <p/>
+     */
+    inline AvailabilityZone& WithSupportedPlatforms(Aws::Vector<SupportedPlatform>&& value) { SetSupportedPlatforms(std::move(value)); return *this;}
+
+    /**
+     * <p/>
+     */
+    inline AvailabilityZone& AddSupportedPlatforms(const SupportedPlatform& value) { m_supportedPlatformsHasBeenSet = true; m_supportedPlatforms.push_back(value); return *this; }
+
+    /**
+     * <p/>
+     */
+    inline AvailabilityZone& AddSupportedPlatforms(SupportedPlatform&& value) { m_supportedPlatformsHasBeenSet = true; m_supportedPlatforms.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    Aws::Vector<SupportedPlatform> m_supportedPlatforms;
+    bool m_supportedPlatformsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/BatchDeleteClusterSnapshotsRequest.h

@@ -0,0 +1,88 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/DeleteClusterSnapshotMessage.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_REDSHIFT_API BatchDeleteClusterSnapshotsRequest : public RedshiftRequest
+  {
+  public:
+    BatchDeleteClusterSnapshotsRequest();
+
+    // 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 "BatchDeleteClusterSnapshots"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>A list of identifiers for the snapshots that you want to delete.</p>
+     */
+    inline const Aws::Vector<DeleteClusterSnapshotMessage>& GetIdentifiers() const{ return m_identifiers; }
+
+    /**
+     * <p>A list of identifiers for the snapshots that you want to delete.</p>
+     */
+    inline bool IdentifiersHasBeenSet() const { return m_identifiersHasBeenSet; }
+
+    /**
+     * <p>A list of identifiers for the snapshots that you want to delete.</p>
+     */
+    inline void SetIdentifiers(const Aws::Vector<DeleteClusterSnapshotMessage>& value) { m_identifiersHasBeenSet = true; m_identifiers = value; }
+
+    /**
+     * <p>A list of identifiers for the snapshots that you want to delete.</p>
+     */
+    inline void SetIdentifiers(Aws::Vector<DeleteClusterSnapshotMessage>&& value) { m_identifiersHasBeenSet = true; m_identifiers = std::move(value); }
+
+    /**
+     * <p>A list of identifiers for the snapshots that you want to delete.</p>
+     */
+    inline BatchDeleteClusterSnapshotsRequest& WithIdentifiers(const Aws::Vector<DeleteClusterSnapshotMessage>& value) { SetIdentifiers(value); return *this;}
+
+    /**
+     * <p>A list of identifiers for the snapshots that you want to delete.</p>
+     */
+    inline BatchDeleteClusterSnapshotsRequest& WithIdentifiers(Aws::Vector<DeleteClusterSnapshotMessage>&& value) { SetIdentifiers(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of identifiers for the snapshots that you want to delete.</p>
+     */
+    inline BatchDeleteClusterSnapshotsRequest& AddIdentifiers(const DeleteClusterSnapshotMessage& value) { m_identifiersHasBeenSet = true; m_identifiers.push_back(value); return *this; }
+
+    /**
+     * <p>A list of identifiers for the snapshots that you want to delete.</p>
+     */
+    inline BatchDeleteClusterSnapshotsRequest& AddIdentifiers(DeleteClusterSnapshotMessage&& value) { m_identifiersHasBeenSet = true; m_identifiers.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::Vector<DeleteClusterSnapshotMessage> m_identifiers;
+    bool m_identifiersHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/BatchDeleteClusterSnapshotsResult.h

@@ -0,0 +1,141 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/redshift/model/SnapshotErrorMessage.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  class AWS_REDSHIFT_API BatchDeleteClusterSnapshotsResult
+  {
+  public:
+    BatchDeleteClusterSnapshotsResult();
+    BatchDeleteClusterSnapshotsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    BatchDeleteClusterSnapshotsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    /**
+     * <p>A list of the snapshot identifiers that were deleted. </p>
+     */
+    inline const Aws::Vector<Aws::String>& GetResources() const{ return m_resources; }
+
+    /**
+     * <p>A list of the snapshot identifiers that were deleted. </p>
+     */
+    inline void SetResources(const Aws::Vector<Aws::String>& value) { m_resources = value; }
+
+    /**
+     * <p>A list of the snapshot identifiers that were deleted. </p>
+     */
+    inline void SetResources(Aws::Vector<Aws::String>&& value) { m_resources = std::move(value); }
+
+    /**
+     * <p>A list of the snapshot identifiers that were deleted. </p>
+     */
+    inline BatchDeleteClusterSnapshotsResult& WithResources(const Aws::Vector<Aws::String>& value) { SetResources(value); return *this;}
+
+    /**
+     * <p>A list of the snapshot identifiers that were deleted. </p>
+     */
+    inline BatchDeleteClusterSnapshotsResult& WithResources(Aws::Vector<Aws::String>&& value) { SetResources(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of the snapshot identifiers that were deleted. </p>
+     */
+    inline BatchDeleteClusterSnapshotsResult& AddResources(const Aws::String& value) { m_resources.push_back(value); return *this; }
+
+    /**
+     * <p>A list of the snapshot identifiers that were deleted. </p>
+     */
+    inline BatchDeleteClusterSnapshotsResult& AddResources(Aws::String&& value) { m_resources.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>A list of the snapshot identifiers that were deleted. </p>
+     */
+    inline BatchDeleteClusterSnapshotsResult& AddResources(const char* value) { m_resources.push_back(value); return *this; }
+
+
+    /**
+     * <p>A list of any errors returned.</p>
+     */
+    inline const Aws::Vector<SnapshotErrorMessage>& GetErrors() const{ return m_errors; }
+
+    /**
+     * <p>A list of any errors returned.</p>
+     */
+    inline void SetErrors(const Aws::Vector<SnapshotErrorMessage>& value) { m_errors = value; }
+
+    /**
+     * <p>A list of any errors returned.</p>
+     */
+    inline void SetErrors(Aws::Vector<SnapshotErrorMessage>&& value) { m_errors = std::move(value); }
+
+    /**
+     * <p>A list of any errors returned.</p>
+     */
+    inline BatchDeleteClusterSnapshotsResult& WithErrors(const Aws::Vector<SnapshotErrorMessage>& value) { SetErrors(value); return *this;}
+
+    /**
+     * <p>A list of any errors returned.</p>
+     */
+    inline BatchDeleteClusterSnapshotsResult& WithErrors(Aws::Vector<SnapshotErrorMessage>&& value) { SetErrors(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of any errors returned.</p>
+     */
+    inline BatchDeleteClusterSnapshotsResult& AddErrors(const SnapshotErrorMessage& value) { m_errors.push_back(value); return *this; }
+
+    /**
+     * <p>A list of any errors returned.</p>
+     */
+    inline BatchDeleteClusterSnapshotsResult& AddErrors(SnapshotErrorMessage&& value) { m_errors.push_back(std::move(value)); return *this; }
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline BatchDeleteClusterSnapshotsResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline BatchDeleteClusterSnapshotsResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    Aws::Vector<Aws::String> m_resources;
+
+    Aws::Vector<SnapshotErrorMessage> m_errors;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/BatchModifyClusterSnapshotsRequest.h

@@ -0,0 +1,169 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_REDSHIFT_API BatchModifyClusterSnapshotsRequest : public RedshiftRequest
+  {
+  public:
+    BatchModifyClusterSnapshotsRequest();
+
+    // 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 "BatchModifyClusterSnapshots"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>A list of snapshot identifiers you want to modify.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetSnapshotIdentifierList() const{ return m_snapshotIdentifierList; }
+
+    /**
+     * <p>A list of snapshot identifiers you want to modify.</p>
+     */
+    inline bool SnapshotIdentifierListHasBeenSet() const { return m_snapshotIdentifierListHasBeenSet; }
+
+    /**
+     * <p>A list of snapshot identifiers you want to modify.</p>
+     */
+    inline void SetSnapshotIdentifierList(const Aws::Vector<Aws::String>& value) { m_snapshotIdentifierListHasBeenSet = true; m_snapshotIdentifierList = value; }
+
+    /**
+     * <p>A list of snapshot identifiers you want to modify.</p>
+     */
+    inline void SetSnapshotIdentifierList(Aws::Vector<Aws::String>&& value) { m_snapshotIdentifierListHasBeenSet = true; m_snapshotIdentifierList = std::move(value); }
+
+    /**
+     * <p>A list of snapshot identifiers you want to modify.</p>
+     */
+    inline BatchModifyClusterSnapshotsRequest& WithSnapshotIdentifierList(const Aws::Vector<Aws::String>& value) { SetSnapshotIdentifierList(value); return *this;}
+
+    /**
+     * <p>A list of snapshot identifiers you want to modify.</p>
+     */
+    inline BatchModifyClusterSnapshotsRequest& WithSnapshotIdentifierList(Aws::Vector<Aws::String>&& value) { SetSnapshotIdentifierList(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of snapshot identifiers you want to modify.</p>
+     */
+    inline BatchModifyClusterSnapshotsRequest& AddSnapshotIdentifierList(const Aws::String& value) { m_snapshotIdentifierListHasBeenSet = true; m_snapshotIdentifierList.push_back(value); return *this; }
+
+    /**
+     * <p>A list of snapshot identifiers you want to modify.</p>
+     */
+    inline BatchModifyClusterSnapshotsRequest& AddSnapshotIdentifierList(Aws::String&& value) { m_snapshotIdentifierListHasBeenSet = true; m_snapshotIdentifierList.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>A list of snapshot identifiers you want to modify.</p>
+     */
+    inline BatchModifyClusterSnapshotsRequest& AddSnapshotIdentifierList(const char* value) { m_snapshotIdentifierListHasBeenSet = true; m_snapshotIdentifierList.push_back(value); return *this; }
+
+
+    /**
+     * <p>The number of days that a manual snapshot is retained. If you specify the
+     * value -1, the manual snapshot is retained indefinitely.</p> <p>The number must
+     * be either -1 or an integer between 1 and 3,653.</p> <p>If you decrease the
+     * manual snapshot retention period from its current value, existing manual
+     * snapshots that fall outside of the new retention period will return an error. If
+     * you want to suppress the errors and delete the snapshots, use the force option.
+     * </p>
+     */
+    inline int GetManualSnapshotRetentionPeriod() const{ return m_manualSnapshotRetentionPeriod; }
+
+    /**
+     * <p>The number of days that a manual snapshot is retained. If you specify the
+     * value -1, the manual snapshot is retained indefinitely.</p> <p>The number must
+     * be either -1 or an integer between 1 and 3,653.</p> <p>If you decrease the
+     * manual snapshot retention period from its current value, existing manual
+     * snapshots that fall outside of the new retention period will return an error. If
+     * you want to suppress the errors and delete the snapshots, use the force option.
+     * </p>
+     */
+    inline bool ManualSnapshotRetentionPeriodHasBeenSet() const { return m_manualSnapshotRetentionPeriodHasBeenSet; }
+
+    /**
+     * <p>The number of days that a manual snapshot is retained. If you specify the
+     * value -1, the manual snapshot is retained indefinitely.</p> <p>The number must
+     * be either -1 or an integer between 1 and 3,653.</p> <p>If you decrease the
+     * manual snapshot retention period from its current value, existing manual
+     * snapshots that fall outside of the new retention period will return an error. If
+     * you want to suppress the errors and delete the snapshots, use the force option.
+     * </p>
+     */
+    inline void SetManualSnapshotRetentionPeriod(int value) { m_manualSnapshotRetentionPeriodHasBeenSet = true; m_manualSnapshotRetentionPeriod = value; }
+
+    /**
+     * <p>The number of days that a manual snapshot is retained. If you specify the
+     * value -1, the manual snapshot is retained indefinitely.</p> <p>The number must
+     * be either -1 or an integer between 1 and 3,653.</p> <p>If you decrease the
+     * manual snapshot retention period from its current value, existing manual
+     * snapshots that fall outside of the new retention period will return an error. If
+     * you want to suppress the errors and delete the snapshots, use the force option.
+     * </p>
+     */
+    inline BatchModifyClusterSnapshotsRequest& WithManualSnapshotRetentionPeriod(int value) { SetManualSnapshotRetentionPeriod(value); return *this;}
+
+
+    /**
+     * <p>A boolean value indicating whether to override an exception if the retention
+     * period has passed. </p>
+     */
+    inline bool GetForce() const{ return m_force; }
+
+    /**
+     * <p>A boolean value indicating whether to override an exception if the retention
+     * period has passed. </p>
+     */
+    inline bool ForceHasBeenSet() const { return m_forceHasBeenSet; }
+
+    /**
+     * <p>A boolean value indicating whether to override an exception if the retention
+     * period has passed. </p>
+     */
+    inline void SetForce(bool value) { m_forceHasBeenSet = true; m_force = value; }
+
+    /**
+     * <p>A boolean value indicating whether to override an exception if the retention
+     * period has passed. </p>
+     */
+    inline BatchModifyClusterSnapshotsRequest& WithForce(bool value) { SetForce(value); return *this;}
+
+  private:
+
+    Aws::Vector<Aws::String> m_snapshotIdentifierList;
+    bool m_snapshotIdentifierListHasBeenSet;
+
+    int m_manualSnapshotRetentionPeriod;
+    bool m_manualSnapshotRetentionPeriodHasBeenSet;
+
+    bool m_force;
+    bool m_forceHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/BatchModifyClusterSnapshotsResult.h

@@ -0,0 +1,141 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/redshift/model/SnapshotErrorMessage.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  class AWS_REDSHIFT_API BatchModifyClusterSnapshotsResult
+  {
+  public:
+    BatchModifyClusterSnapshotsResult();
+    BatchModifyClusterSnapshotsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    BatchModifyClusterSnapshotsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    /**
+     * <p>A list of the snapshots that were modified.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetResources() const{ return m_resources; }
+
+    /**
+     * <p>A list of the snapshots that were modified.</p>
+     */
+    inline void SetResources(const Aws::Vector<Aws::String>& value) { m_resources = value; }
+
+    /**
+     * <p>A list of the snapshots that were modified.</p>
+     */
+    inline void SetResources(Aws::Vector<Aws::String>&& value) { m_resources = std::move(value); }
+
+    /**
+     * <p>A list of the snapshots that were modified.</p>
+     */
+    inline BatchModifyClusterSnapshotsResult& WithResources(const Aws::Vector<Aws::String>& value) { SetResources(value); return *this;}
+
+    /**
+     * <p>A list of the snapshots that were modified.</p>
+     */
+    inline BatchModifyClusterSnapshotsResult& WithResources(Aws::Vector<Aws::String>&& value) { SetResources(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of the snapshots that were modified.</p>
+     */
+    inline BatchModifyClusterSnapshotsResult& AddResources(const Aws::String& value) { m_resources.push_back(value); return *this; }
+
+    /**
+     * <p>A list of the snapshots that were modified.</p>
+     */
+    inline BatchModifyClusterSnapshotsResult& AddResources(Aws::String&& value) { m_resources.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>A list of the snapshots that were modified.</p>
+     */
+    inline BatchModifyClusterSnapshotsResult& AddResources(const char* value) { m_resources.push_back(value); return *this; }
+
+
+    /**
+     * <p>A list of any errors returned.</p>
+     */
+    inline const Aws::Vector<SnapshotErrorMessage>& GetErrors() const{ return m_errors; }
+
+    /**
+     * <p>A list of any errors returned.</p>
+     */
+    inline void SetErrors(const Aws::Vector<SnapshotErrorMessage>& value) { m_errors = value; }
+
+    /**
+     * <p>A list of any errors returned.</p>
+     */
+    inline void SetErrors(Aws::Vector<SnapshotErrorMessage>&& value) { m_errors = std::move(value); }
+
+    /**
+     * <p>A list of any errors returned.</p>
+     */
+    inline BatchModifyClusterSnapshotsResult& WithErrors(const Aws::Vector<SnapshotErrorMessage>& value) { SetErrors(value); return *this;}
+
+    /**
+     * <p>A list of any errors returned.</p>
+     */
+    inline BatchModifyClusterSnapshotsResult& WithErrors(Aws::Vector<SnapshotErrorMessage>&& value) { SetErrors(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of any errors returned.</p>
+     */
+    inline BatchModifyClusterSnapshotsResult& AddErrors(const SnapshotErrorMessage& value) { m_errors.push_back(value); return *this; }
+
+    /**
+     * <p>A list of any errors returned.</p>
+     */
+    inline BatchModifyClusterSnapshotsResult& AddErrors(SnapshotErrorMessage&& value) { m_errors.push_back(std::move(value)); return *this; }
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline BatchModifyClusterSnapshotsResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline BatchModifyClusterSnapshotsResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    Aws::Vector<Aws::String> m_resources;
+
+    Aws::Vector<SnapshotErrorMessage> m_errors;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/CancelResizeRequest.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/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_REDSHIFT_API CancelResizeRequest : public RedshiftRequest
+  {
+  public:
+    CancelResizeRequest();
+
+    // 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 "CancelResize"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The unique identifier for the cluster that you want to cancel a resize
+     * operation for.</p>
+     */
+    inline const Aws::String& GetClusterIdentifier() const{ return m_clusterIdentifier; }
+
+    /**
+     * <p>The unique identifier for the cluster that you want to cancel a resize
+     * operation for.</p>
+     */
+    inline bool ClusterIdentifierHasBeenSet() const { return m_clusterIdentifierHasBeenSet; }
+
+    /**
+     * <p>The unique identifier for the cluster that you want to cancel a resize
+     * operation for.</p>
+     */
+    inline void SetClusterIdentifier(const Aws::String& value) { m_clusterIdentifierHasBeenSet = true; m_clusterIdentifier = value; }
+
+    /**
+     * <p>The unique identifier for the cluster that you want to cancel a resize
+     * operation for.</p>
+     */
+    inline void SetClusterIdentifier(Aws::String&& value) { m_clusterIdentifierHasBeenSet = true; m_clusterIdentifier = std::move(value); }
+
+    /**
+     * <p>The unique identifier for the cluster that you want to cancel a resize
+     * operation for.</p>
+     */
+    inline void SetClusterIdentifier(const char* value) { m_clusterIdentifierHasBeenSet = true; m_clusterIdentifier.assign(value); }
+
+    /**
+     * <p>The unique identifier for the cluster that you want to cancel a resize
+     * operation for.</p>
+     */
+    inline CancelResizeRequest& WithClusterIdentifier(const Aws::String& value) { SetClusterIdentifier(value); return *this;}
+
+    /**
+     * <p>The unique identifier for the cluster that you want to cancel a resize
+     * operation for.</p>
+     */
+    inline CancelResizeRequest& WithClusterIdentifier(Aws::String&& value) { SetClusterIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>The unique identifier for the cluster that you want to cancel a resize
+     * operation for.</p>
+     */
+    inline CancelResizeRequest& WithClusterIdentifier(const char* value) { SetClusterIdentifier(value); return *this;}
+
+  private:
+
+    Aws::String m_clusterIdentifier;
+    bool m_clusterIdentifierHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/CancelResizeResult.h

@@ -0,0 +1,667 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  /**
+   * <p>Describes the result of a cluster resize operation.</p><p><h3>See Also:</h3> 
+   * <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/ResizeProgressMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API CancelResizeResult
+  {
+  public:
+    CancelResizeResult();
+    CancelResizeResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    CancelResizeResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    /**
+     * <p>The node type that the cluster will have after the resize operation is
+     * complete.</p>
+     */
+    inline const Aws::String& GetTargetNodeType() const{ return m_targetNodeType; }
+
+    /**
+     * <p>The node type that the cluster will have after the resize operation is
+     * complete.</p>
+     */
+    inline void SetTargetNodeType(const Aws::String& value) { m_targetNodeType = value; }
+
+    /**
+     * <p>The node type that the cluster will have after the resize operation is
+     * complete.</p>
+     */
+    inline void SetTargetNodeType(Aws::String&& value) { m_targetNodeType = std::move(value); }
+
+    /**
+     * <p>The node type that the cluster will have after the resize operation is
+     * complete.</p>
+     */
+    inline void SetTargetNodeType(const char* value) { m_targetNodeType.assign(value); }
+
+    /**
+     * <p>The node type that the cluster will have after the resize operation is
+     * complete.</p>
+     */
+    inline CancelResizeResult& WithTargetNodeType(const Aws::String& value) { SetTargetNodeType(value); return *this;}
+
+    /**
+     * <p>The node type that the cluster will have after the resize operation is
+     * complete.</p>
+     */
+    inline CancelResizeResult& WithTargetNodeType(Aws::String&& value) { SetTargetNodeType(std::move(value)); return *this;}
+
+    /**
+     * <p>The node type that the cluster will have after the resize operation is
+     * complete.</p>
+     */
+    inline CancelResizeResult& WithTargetNodeType(const char* value) { SetTargetNodeType(value); return *this;}
+
+
+    /**
+     * <p>The number of nodes that the cluster will have after the resize operation is
+     * complete.</p>
+     */
+    inline int GetTargetNumberOfNodes() const{ return m_targetNumberOfNodes; }
+
+    /**
+     * <p>The number of nodes that the cluster will have after the resize operation is
+     * complete.</p>
+     */
+    inline void SetTargetNumberOfNodes(int value) { m_targetNumberOfNodes = value; }
+
+    /**
+     * <p>The number of nodes that the cluster will have after the resize operation is
+     * complete.</p>
+     */
+    inline CancelResizeResult& WithTargetNumberOfNodes(int value) { SetTargetNumberOfNodes(value); return *this;}
+
+
+    /**
+     * <p>The cluster type after the resize operation is complete.</p> <p>Valid Values:
+     * <code>multi-node</code> | <code>single-node</code> </p>
+     */
+    inline const Aws::String& GetTargetClusterType() const{ return m_targetClusterType; }
+
+    /**
+     * <p>The cluster type after the resize operation is complete.</p> <p>Valid Values:
+     * <code>multi-node</code> | <code>single-node</code> </p>
+     */
+    inline void SetTargetClusterType(const Aws::String& value) { m_targetClusterType = value; }
+
+    /**
+     * <p>The cluster type after the resize operation is complete.</p> <p>Valid Values:
+     * <code>multi-node</code> | <code>single-node</code> </p>
+     */
+    inline void SetTargetClusterType(Aws::String&& value) { m_targetClusterType = std::move(value); }
+
+    /**
+     * <p>The cluster type after the resize operation is complete.</p> <p>Valid Values:
+     * <code>multi-node</code> | <code>single-node</code> </p>
+     */
+    inline void SetTargetClusterType(const char* value) { m_targetClusterType.assign(value); }
+
+    /**
+     * <p>The cluster type after the resize operation is complete.</p> <p>Valid Values:
+     * <code>multi-node</code> | <code>single-node</code> </p>
+     */
+    inline CancelResizeResult& WithTargetClusterType(const Aws::String& value) { SetTargetClusterType(value); return *this;}
+
+    /**
+     * <p>The cluster type after the resize operation is complete.</p> <p>Valid Values:
+     * <code>multi-node</code> | <code>single-node</code> </p>
+     */
+    inline CancelResizeResult& WithTargetClusterType(Aws::String&& value) { SetTargetClusterType(std::move(value)); return *this;}
+
+    /**
+     * <p>The cluster type after the resize operation is complete.</p> <p>Valid Values:
+     * <code>multi-node</code> | <code>single-node</code> </p>
+     */
+    inline CancelResizeResult& WithTargetClusterType(const char* value) { SetTargetClusterType(value); return *this;}
+
+
+    /**
+     * <p>The status of the resize operation.</p> <p>Valid Values: <code>NONE</code> |
+     * <code>IN_PROGRESS</code> | <code>FAILED</code> | <code>SUCCEEDED</code> |
+     * <code>CANCELLING</code> </p>
+     */
+    inline const Aws::String& GetStatus() const{ return m_status; }
+
+    /**
+     * <p>The status of the resize operation.</p> <p>Valid Values: <code>NONE</code> |
+     * <code>IN_PROGRESS</code> | <code>FAILED</code> | <code>SUCCEEDED</code> |
+     * <code>CANCELLING</code> </p>
+     */
+    inline void SetStatus(const Aws::String& value) { m_status = value; }
+
+    /**
+     * <p>The status of the resize operation.</p> <p>Valid Values: <code>NONE</code> |
+     * <code>IN_PROGRESS</code> | <code>FAILED</code> | <code>SUCCEEDED</code> |
+     * <code>CANCELLING</code> </p>
+     */
+    inline void SetStatus(Aws::String&& value) { m_status = std::move(value); }
+
+    /**
+     * <p>The status of the resize operation.</p> <p>Valid Values: <code>NONE</code> |
+     * <code>IN_PROGRESS</code> | <code>FAILED</code> | <code>SUCCEEDED</code> |
+     * <code>CANCELLING</code> </p>
+     */
+    inline void SetStatus(const char* value) { m_status.assign(value); }
+
+    /**
+     * <p>The status of the resize operation.</p> <p>Valid Values: <code>NONE</code> |
+     * <code>IN_PROGRESS</code> | <code>FAILED</code> | <code>SUCCEEDED</code> |
+     * <code>CANCELLING</code> </p>
+     */
+    inline CancelResizeResult& WithStatus(const Aws::String& value) { SetStatus(value); return *this;}
+
+    /**
+     * <p>The status of the resize operation.</p> <p>Valid Values: <code>NONE</code> |
+     * <code>IN_PROGRESS</code> | <code>FAILED</code> | <code>SUCCEEDED</code> |
+     * <code>CANCELLING</code> </p>
+     */
+    inline CancelResizeResult& WithStatus(Aws::String&& value) { SetStatus(std::move(value)); return *this;}
+
+    /**
+     * <p>The status of the resize operation.</p> <p>Valid Values: <code>NONE</code> |
+     * <code>IN_PROGRESS</code> | <code>FAILED</code> | <code>SUCCEEDED</code> |
+     * <code>CANCELLING</code> </p>
+     */
+    inline CancelResizeResult& WithStatus(const char* value) { SetStatus(value); return *this;}
+
+
+    /**
+     * <p>The names of tables that have been completely imported .</p> <p>Valid Values:
+     * List of table names.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetImportTablesCompleted() const{ return m_importTablesCompleted; }
+
+    /**
+     * <p>The names of tables that have been completely imported .</p> <p>Valid Values:
+     * List of table names.</p>
+     */
+    inline void SetImportTablesCompleted(const Aws::Vector<Aws::String>& value) { m_importTablesCompleted = value; }
+
+    /**
+     * <p>The names of tables that have been completely imported .</p> <p>Valid Values:
+     * List of table names.</p>
+     */
+    inline void SetImportTablesCompleted(Aws::Vector<Aws::String>&& value) { m_importTablesCompleted = std::move(value); }
+
+    /**
+     * <p>The names of tables that have been completely imported .</p> <p>Valid Values:
+     * List of table names.</p>
+     */
+    inline CancelResizeResult& WithImportTablesCompleted(const Aws::Vector<Aws::String>& value) { SetImportTablesCompleted(value); return *this;}
+
+    /**
+     * <p>The names of tables that have been completely imported .</p> <p>Valid Values:
+     * List of table names.</p>
+     */
+    inline CancelResizeResult& WithImportTablesCompleted(Aws::Vector<Aws::String>&& value) { SetImportTablesCompleted(std::move(value)); return *this;}
+
+    /**
+     * <p>The names of tables that have been completely imported .</p> <p>Valid Values:
+     * List of table names.</p>
+     */
+    inline CancelResizeResult& AddImportTablesCompleted(const Aws::String& value) { m_importTablesCompleted.push_back(value); return *this; }
+
+    /**
+     * <p>The names of tables that have been completely imported .</p> <p>Valid Values:
+     * List of table names.</p>
+     */
+    inline CancelResizeResult& AddImportTablesCompleted(Aws::String&& value) { m_importTablesCompleted.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>The names of tables that have been completely imported .</p> <p>Valid Values:
+     * List of table names.</p>
+     */
+    inline CancelResizeResult& AddImportTablesCompleted(const char* value) { m_importTablesCompleted.push_back(value); return *this; }
+
+
+    /**
+     * <p>The names of tables that are being currently imported.</p> <p>Valid Values:
+     * List of table names.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetImportTablesInProgress() const{ return m_importTablesInProgress; }
+
+    /**
+     * <p>The names of tables that are being currently imported.</p> <p>Valid Values:
+     * List of table names.</p>
+     */
+    inline void SetImportTablesInProgress(const Aws::Vector<Aws::String>& value) { m_importTablesInProgress = value; }
+
+    /**
+     * <p>The names of tables that are being currently imported.</p> <p>Valid Values:
+     * List of table names.</p>
+     */
+    inline void SetImportTablesInProgress(Aws::Vector<Aws::String>&& value) { m_importTablesInProgress = std::move(value); }
+
+    /**
+     * <p>The names of tables that are being currently imported.</p> <p>Valid Values:
+     * List of table names.</p>
+     */
+    inline CancelResizeResult& WithImportTablesInProgress(const Aws::Vector<Aws::String>& value) { SetImportTablesInProgress(value); return *this;}
+
+    /**
+     * <p>The names of tables that are being currently imported.</p> <p>Valid Values:
+     * List of table names.</p>
+     */
+    inline CancelResizeResult& WithImportTablesInProgress(Aws::Vector<Aws::String>&& value) { SetImportTablesInProgress(std::move(value)); return *this;}
+
+    /**
+     * <p>The names of tables that are being currently imported.</p> <p>Valid Values:
+     * List of table names.</p>
+     */
+    inline CancelResizeResult& AddImportTablesInProgress(const Aws::String& value) { m_importTablesInProgress.push_back(value); return *this; }
+
+    /**
+     * <p>The names of tables that are being currently imported.</p> <p>Valid Values:
+     * List of table names.</p>
+     */
+    inline CancelResizeResult& AddImportTablesInProgress(Aws::String&& value) { m_importTablesInProgress.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>The names of tables that are being currently imported.</p> <p>Valid Values:
+     * List of table names.</p>
+     */
+    inline CancelResizeResult& AddImportTablesInProgress(const char* value) { m_importTablesInProgress.push_back(value); return *this; }
+
+
+    /**
+     * <p>The names of tables that have not been yet imported.</p> <p>Valid Values:
+     * List of table names</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetImportTablesNotStarted() const{ return m_importTablesNotStarted; }
+
+    /**
+     * <p>The names of tables that have not been yet imported.</p> <p>Valid Values:
+     * List of table names</p>
+     */
+    inline void SetImportTablesNotStarted(const Aws::Vector<Aws::String>& value) { m_importTablesNotStarted = value; }
+
+    /**
+     * <p>The names of tables that have not been yet imported.</p> <p>Valid Values:
+     * List of table names</p>
+     */
+    inline void SetImportTablesNotStarted(Aws::Vector<Aws::String>&& value) { m_importTablesNotStarted = std::move(value); }
+
+    /**
+     * <p>The names of tables that have not been yet imported.</p> <p>Valid Values:
+     * List of table names</p>
+     */
+    inline CancelResizeResult& WithImportTablesNotStarted(const Aws::Vector<Aws::String>& value) { SetImportTablesNotStarted(value); return *this;}
+
+    /**
+     * <p>The names of tables that have not been yet imported.</p> <p>Valid Values:
+     * List of table names</p>
+     */
+    inline CancelResizeResult& WithImportTablesNotStarted(Aws::Vector<Aws::String>&& value) { SetImportTablesNotStarted(std::move(value)); return *this;}
+
+    /**
+     * <p>The names of tables that have not been yet imported.</p> <p>Valid Values:
+     * List of table names</p>
+     */
+    inline CancelResizeResult& AddImportTablesNotStarted(const Aws::String& value) { m_importTablesNotStarted.push_back(value); return *this; }
+
+    /**
+     * <p>The names of tables that have not been yet imported.</p> <p>Valid Values:
+     * List of table names</p>
+     */
+    inline CancelResizeResult& AddImportTablesNotStarted(Aws::String&& value) { m_importTablesNotStarted.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>The names of tables that have not been yet imported.</p> <p>Valid Values:
+     * List of table names</p>
+     */
+    inline CancelResizeResult& AddImportTablesNotStarted(const char* value) { m_importTablesNotStarted.push_back(value); return *this; }
+
+
+    /**
+     * <p>The average rate of the resize operation over the last few minutes, measured
+     * in megabytes per second. After the resize operation completes, this value shows
+     * the average rate of the entire resize operation.</p>
+     */
+    inline double GetAvgResizeRateInMegaBytesPerSecond() const{ return m_avgResizeRateInMegaBytesPerSecond; }
+
+    /**
+     * <p>The average rate of the resize operation over the last few minutes, measured
+     * in megabytes per second. After the resize operation completes, this value shows
+     * the average rate of the entire resize operation.</p>
+     */
+    inline void SetAvgResizeRateInMegaBytesPerSecond(double value) { m_avgResizeRateInMegaBytesPerSecond = value; }
+
+    /**
+     * <p>The average rate of the resize operation over the last few minutes, measured
+     * in megabytes per second. After the resize operation completes, this value shows
+     * the average rate of the entire resize operation.</p>
+     */
+    inline CancelResizeResult& WithAvgResizeRateInMegaBytesPerSecond(double value) { SetAvgResizeRateInMegaBytesPerSecond(value); return *this;}
+
+
+    /**
+     * <p>The estimated total amount of data, in megabytes, on the cluster before the
+     * resize operation began.</p>
+     */
+    inline long long GetTotalResizeDataInMegaBytes() const{ return m_totalResizeDataInMegaBytes; }
+
+    /**
+     * <p>The estimated total amount of data, in megabytes, on the cluster before the
+     * resize operation began.</p>
+     */
+    inline void SetTotalResizeDataInMegaBytes(long long value) { m_totalResizeDataInMegaBytes = value; }
+
+    /**
+     * <p>The estimated total amount of data, in megabytes, on the cluster before the
+     * resize operation began.</p>
+     */
+    inline CancelResizeResult& WithTotalResizeDataInMegaBytes(long long value) { SetTotalResizeDataInMegaBytes(value); return *this;}
+
+
+    /**
+     * <p>While the resize operation is in progress, this value shows the current
+     * amount of data, in megabytes, that has been processed so far. When the resize
+     * operation is complete, this value shows the total amount of data, in megabytes,
+     * on the cluster, which may be more or less than TotalResizeDataInMegaBytes (the
+     * estimated total amount of data before resize).</p>
+     */
+    inline long long GetProgressInMegaBytes() const{ return m_progressInMegaBytes; }
+
+    /**
+     * <p>While the resize operation is in progress, this value shows the current
+     * amount of data, in megabytes, that has been processed so far. When the resize
+     * operation is complete, this value shows the total amount of data, in megabytes,
+     * on the cluster, which may be more or less than TotalResizeDataInMegaBytes (the
+     * estimated total amount of data before resize).</p>
+     */
+    inline void SetProgressInMegaBytes(long long value) { m_progressInMegaBytes = value; }
+
+    /**
+     * <p>While the resize operation is in progress, this value shows the current
+     * amount of data, in megabytes, that has been processed so far. When the resize
+     * operation is complete, this value shows the total amount of data, in megabytes,
+     * on the cluster, which may be more or less than TotalResizeDataInMegaBytes (the
+     * estimated total amount of data before resize).</p>
+     */
+    inline CancelResizeResult& WithProgressInMegaBytes(long long value) { SetProgressInMegaBytes(value); return *this;}
+
+
+    /**
+     * <p>The amount of seconds that have elapsed since the resize operation began.
+     * After the resize operation completes, this value shows the total actual time, in
+     * seconds, for the resize operation.</p>
+     */
+    inline long long GetElapsedTimeInSeconds() const{ return m_elapsedTimeInSeconds; }
+
+    /**
+     * <p>The amount of seconds that have elapsed since the resize operation began.
+     * After the resize operation completes, this value shows the total actual time, in
+     * seconds, for the resize operation.</p>
+     */
+    inline void SetElapsedTimeInSeconds(long long value) { m_elapsedTimeInSeconds = value; }
+
+    /**
+     * <p>The amount of seconds that have elapsed since the resize operation began.
+     * After the resize operation completes, this value shows the total actual time, in
+     * seconds, for the resize operation.</p>
+     */
+    inline CancelResizeResult& WithElapsedTimeInSeconds(long long value) { SetElapsedTimeInSeconds(value); return *this;}
+
+
+    /**
+     * <p>The estimated time remaining, in seconds, until the resize operation is
+     * complete. This value is calculated based on the average resize rate and the
+     * estimated amount of data remaining to be processed. Once the resize operation is
+     * complete, this value will be 0.</p>
+     */
+    inline long long GetEstimatedTimeToCompletionInSeconds() const{ return m_estimatedTimeToCompletionInSeconds; }
+
+    /**
+     * <p>The estimated time remaining, in seconds, until the resize operation is
+     * complete. This value is calculated based on the average resize rate and the
+     * estimated amount of data remaining to be processed. Once the resize operation is
+     * complete, this value will be 0.</p>
+     */
+    inline void SetEstimatedTimeToCompletionInSeconds(long long value) { m_estimatedTimeToCompletionInSeconds = value; }
+
+    /**
+     * <p>The estimated time remaining, in seconds, until the resize operation is
+     * complete. This value is calculated based on the average resize rate and the
+     * estimated amount of data remaining to be processed. Once the resize operation is
+     * complete, this value will be 0.</p>
+     */
+    inline CancelResizeResult& WithEstimatedTimeToCompletionInSeconds(long long value) { SetEstimatedTimeToCompletionInSeconds(value); return *this;}
+
+
+    /**
+     * <p>An enum with possible values of <code>ClassicResize</code> and
+     * <code>ElasticResize</code>. These values describe the type of resize operation
+     * being performed. </p>
+     */
+    inline const Aws::String& GetResizeType() const{ return m_resizeType; }
+
+    /**
+     * <p>An enum with possible values of <code>ClassicResize</code> and
+     * <code>ElasticResize</code>. These values describe the type of resize operation
+     * being performed. </p>
+     */
+    inline void SetResizeType(const Aws::String& value) { m_resizeType = value; }
+
+    /**
+     * <p>An enum with possible values of <code>ClassicResize</code> and
+     * <code>ElasticResize</code>. These values describe the type of resize operation
+     * being performed. </p>
+     */
+    inline void SetResizeType(Aws::String&& value) { m_resizeType = std::move(value); }
+
+    /**
+     * <p>An enum with possible values of <code>ClassicResize</code> and
+     * <code>ElasticResize</code>. These values describe the type of resize operation
+     * being performed. </p>
+     */
+    inline void SetResizeType(const char* value) { m_resizeType.assign(value); }
+
+    /**
+     * <p>An enum with possible values of <code>ClassicResize</code> and
+     * <code>ElasticResize</code>. These values describe the type of resize operation
+     * being performed. </p>
+     */
+    inline CancelResizeResult& WithResizeType(const Aws::String& value) { SetResizeType(value); return *this;}
+
+    /**
+     * <p>An enum with possible values of <code>ClassicResize</code> and
+     * <code>ElasticResize</code>. These values describe the type of resize operation
+     * being performed. </p>
+     */
+    inline CancelResizeResult& WithResizeType(Aws::String&& value) { SetResizeType(std::move(value)); return *this;}
+
+    /**
+     * <p>An enum with possible values of <code>ClassicResize</code> and
+     * <code>ElasticResize</code>. These values describe the type of resize operation
+     * being performed. </p>
+     */
+    inline CancelResizeResult& WithResizeType(const char* value) { SetResizeType(value); return *this;}
+
+
+    /**
+     * <p>An optional string to provide additional details about the resize action.</p>
+     */
+    inline const Aws::String& GetMessage() const{ return m_message; }
+
+    /**
+     * <p>An optional string to provide additional details about the resize action.</p>
+     */
+    inline void SetMessage(const Aws::String& value) { m_message = value; }
+
+    /**
+     * <p>An optional string to provide additional details about the resize action.</p>
+     */
+    inline void SetMessage(Aws::String&& value) { m_message = std::move(value); }
+
+    /**
+     * <p>An optional string to provide additional details about the resize action.</p>
+     */
+    inline void SetMessage(const char* value) { m_message.assign(value); }
+
+    /**
+     * <p>An optional string to provide additional details about the resize action.</p>
+     */
+    inline CancelResizeResult& WithMessage(const Aws::String& value) { SetMessage(value); return *this;}
+
+    /**
+     * <p>An optional string to provide additional details about the resize action.</p>
+     */
+    inline CancelResizeResult& WithMessage(Aws::String&& value) { SetMessage(std::move(value)); return *this;}
+
+    /**
+     * <p>An optional string to provide additional details about the resize action.</p>
+     */
+    inline CancelResizeResult& WithMessage(const char* value) { SetMessage(value); return *this;}
+
+
+    /**
+     * <p>The type of encryption for the cluster after the resize is complete.</p>
+     * <p>Possible values are <code>KMS</code> and <code>None</code>. In the China
+     * region possible values are: <code>Legacy</code> and <code>None</code>.</p>
+     */
+    inline const Aws::String& GetTargetEncryptionType() const{ return m_targetEncryptionType; }
+
+    /**
+     * <p>The type of encryption for the cluster after the resize is complete.</p>
+     * <p>Possible values are <code>KMS</code> and <code>None</code>. In the China
+     * region possible values are: <code>Legacy</code> and <code>None</code>.</p>
+     */
+    inline void SetTargetEncryptionType(const Aws::String& value) { m_targetEncryptionType = value; }
+
+    /**
+     * <p>The type of encryption for the cluster after the resize is complete.</p>
+     * <p>Possible values are <code>KMS</code> and <code>None</code>. In the China
+     * region possible values are: <code>Legacy</code> and <code>None</code>.</p>
+     */
+    inline void SetTargetEncryptionType(Aws::String&& value) { m_targetEncryptionType = std::move(value); }
+
+    /**
+     * <p>The type of encryption for the cluster after the resize is complete.</p>
+     * <p>Possible values are <code>KMS</code> and <code>None</code>. In the China
+     * region possible values are: <code>Legacy</code> and <code>None</code>.</p>
+     */
+    inline void SetTargetEncryptionType(const char* value) { m_targetEncryptionType.assign(value); }
+
+    /**
+     * <p>The type of encryption for the cluster after the resize is complete.</p>
+     * <p>Possible values are <code>KMS</code> and <code>None</code>. In the China
+     * region possible values are: <code>Legacy</code> and <code>None</code>.</p>
+     */
+    inline CancelResizeResult& WithTargetEncryptionType(const Aws::String& value) { SetTargetEncryptionType(value); return *this;}
+
+    /**
+     * <p>The type of encryption for the cluster after the resize is complete.</p>
+     * <p>Possible values are <code>KMS</code> and <code>None</code>. In the China
+     * region possible values are: <code>Legacy</code> and <code>None</code>.</p>
+     */
+    inline CancelResizeResult& WithTargetEncryptionType(Aws::String&& value) { SetTargetEncryptionType(std::move(value)); return *this;}
+
+    /**
+     * <p>The type of encryption for the cluster after the resize is complete.</p>
+     * <p>Possible values are <code>KMS</code> and <code>None</code>. In the China
+     * region possible values are: <code>Legacy</code> and <code>None</code>.</p>
+     */
+    inline CancelResizeResult& WithTargetEncryptionType(const char* value) { SetTargetEncryptionType(value); return *this;}
+
+
+    /**
+     * <p>The percent of data transferred from source cluster to target cluster.</p>
+     */
+    inline double GetDataTransferProgressPercent() const{ return m_dataTransferProgressPercent; }
+
+    /**
+     * <p>The percent of data transferred from source cluster to target cluster.</p>
+     */
+    inline void SetDataTransferProgressPercent(double value) { m_dataTransferProgressPercent = value; }
+
+    /**
+     * <p>The percent of data transferred from source cluster to target cluster.</p>
+     */
+    inline CancelResizeResult& WithDataTransferProgressPercent(double value) { SetDataTransferProgressPercent(value); return *this;}
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline CancelResizeResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline CancelResizeResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_targetNodeType;
+
+    int m_targetNumberOfNodes;
+
+    Aws::String m_targetClusterType;
+
+    Aws::String m_status;
+
+    Aws::Vector<Aws::String> m_importTablesCompleted;
+
+    Aws::Vector<Aws::String> m_importTablesInProgress;
+
+    Aws::Vector<Aws::String> m_importTablesNotStarted;
+
+    double m_avgResizeRateInMegaBytesPerSecond;
+
+    long long m_totalResizeDataInMegaBytes;
+
+    long long m_progressInMegaBytes;
+
+    long long m_elapsedTimeInSeconds;
+
+    long long m_estimatedTimeToCompletionInSeconds;
+
+    Aws::String m_resizeType;
+
+    Aws::String m_message;
+
+    Aws::String m_targetEncryptionType;
+
+    double m_dataTransferProgressPercent;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/ClusterAssociatedToSchedule.h

@@ -0,0 +1,125 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/redshift/model/ScheduleState.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p/><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/ClusterAssociatedToSchedule">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API ClusterAssociatedToSchedule
+  {
+  public:
+    ClusterAssociatedToSchedule();
+    ClusterAssociatedToSchedule(const Aws::Utils::Xml::XmlNode& xmlNode);
+    ClusterAssociatedToSchedule& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    /**
+     * <p/>
+     */
+    inline const Aws::String& GetClusterIdentifier() const{ return m_clusterIdentifier; }
+
+    /**
+     * <p/>
+     */
+    inline bool ClusterIdentifierHasBeenSet() const { return m_clusterIdentifierHasBeenSet; }
+
+    /**
+     * <p/>
+     */
+    inline void SetClusterIdentifier(const Aws::String& value) { m_clusterIdentifierHasBeenSet = true; m_clusterIdentifier = value; }
+
+    /**
+     * <p/>
+     */
+    inline void SetClusterIdentifier(Aws::String&& value) { m_clusterIdentifierHasBeenSet = true; m_clusterIdentifier = std::move(value); }
+
+    /**
+     * <p/>
+     */
+    inline void SetClusterIdentifier(const char* value) { m_clusterIdentifierHasBeenSet = true; m_clusterIdentifier.assign(value); }
+
+    /**
+     * <p/>
+     */
+    inline ClusterAssociatedToSchedule& WithClusterIdentifier(const Aws::String& value) { SetClusterIdentifier(value); return *this;}
+
+    /**
+     * <p/>
+     */
+    inline ClusterAssociatedToSchedule& WithClusterIdentifier(Aws::String&& value) { SetClusterIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p/>
+     */
+    inline ClusterAssociatedToSchedule& WithClusterIdentifier(const char* value) { SetClusterIdentifier(value); return *this;}
+
+
+    /**
+     * <p/>
+     */
+    inline const ScheduleState& GetScheduleAssociationState() const{ return m_scheduleAssociationState; }
+
+    /**
+     * <p/>
+     */
+    inline bool ScheduleAssociationStateHasBeenSet() const { return m_scheduleAssociationStateHasBeenSet; }
+
+    /**
+     * <p/>
+     */
+    inline void SetScheduleAssociationState(const ScheduleState& value) { m_scheduleAssociationStateHasBeenSet = true; m_scheduleAssociationState = value; }
+
+    /**
+     * <p/>
+     */
+    inline void SetScheduleAssociationState(ScheduleState&& value) { m_scheduleAssociationStateHasBeenSet = true; m_scheduleAssociationState = std::move(value); }
+
+    /**
+     * <p/>
+     */
+    inline ClusterAssociatedToSchedule& WithScheduleAssociationState(const ScheduleState& value) { SetScheduleAssociationState(value); return *this;}
+
+    /**
+     * <p/>
+     */
+    inline ClusterAssociatedToSchedule& WithScheduleAssociationState(ScheduleState&& value) { SetScheduleAssociationState(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_clusterIdentifier;
+    bool m_clusterIdentifierHasBeenSet;
+
+    ScheduleState m_scheduleAssociationState;
+    bool m_scheduleAssociationStateHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/ClusterDbRevision.h

@@ -0,0 +1,223 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/DateTime.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/RevisionTarget.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p>Describes a <code>ClusterDbRevision</code>.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/ClusterDbRevision">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API ClusterDbRevision
+  {
+  public:
+    ClusterDbRevision();
+    ClusterDbRevision(const Aws::Utils::Xml::XmlNode& xmlNode);
+    ClusterDbRevision& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    /**
+     * <p>The unique identifier of the cluster.</p>
+     */
+    inline const Aws::String& GetClusterIdentifier() const{ return m_clusterIdentifier; }
+
+    /**
+     * <p>The unique identifier of the cluster.</p>
+     */
+    inline bool ClusterIdentifierHasBeenSet() const { return m_clusterIdentifierHasBeenSet; }
+
+    /**
+     * <p>The unique identifier of the cluster.</p>
+     */
+    inline void SetClusterIdentifier(const Aws::String& value) { m_clusterIdentifierHasBeenSet = true; m_clusterIdentifier = value; }
+
+    /**
+     * <p>The unique identifier of the cluster.</p>
+     */
+    inline void SetClusterIdentifier(Aws::String&& value) { m_clusterIdentifierHasBeenSet = true; m_clusterIdentifier = std::move(value); }
+
+    /**
+     * <p>The unique identifier of the cluster.</p>
+     */
+    inline void SetClusterIdentifier(const char* value) { m_clusterIdentifierHasBeenSet = true; m_clusterIdentifier.assign(value); }
+
+    /**
+     * <p>The unique identifier of the cluster.</p>
+     */
+    inline ClusterDbRevision& WithClusterIdentifier(const Aws::String& value) { SetClusterIdentifier(value); return *this;}
+
+    /**
+     * <p>The unique identifier of the cluster.</p>
+     */
+    inline ClusterDbRevision& WithClusterIdentifier(Aws::String&& value) { SetClusterIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>The unique identifier of the cluster.</p>
+     */
+    inline ClusterDbRevision& WithClusterIdentifier(const char* value) { SetClusterIdentifier(value); return *this;}
+
+
+    /**
+     * <p>A string representing the current cluster version.</p>
+     */
+    inline const Aws::String& GetCurrentDatabaseRevision() const{ return m_currentDatabaseRevision; }
+
+    /**
+     * <p>A string representing the current cluster version.</p>
+     */
+    inline bool CurrentDatabaseRevisionHasBeenSet() const { return m_currentDatabaseRevisionHasBeenSet; }
+
+    /**
+     * <p>A string representing the current cluster version.</p>
+     */
+    inline void SetCurrentDatabaseRevision(const Aws::String& value) { m_currentDatabaseRevisionHasBeenSet = true; m_currentDatabaseRevision = value; }
+
+    /**
+     * <p>A string representing the current cluster version.</p>
+     */
+    inline void SetCurrentDatabaseRevision(Aws::String&& value) { m_currentDatabaseRevisionHasBeenSet = true; m_currentDatabaseRevision = std::move(value); }
+
+    /**
+     * <p>A string representing the current cluster version.</p>
+     */
+    inline void SetCurrentDatabaseRevision(const char* value) { m_currentDatabaseRevisionHasBeenSet = true; m_currentDatabaseRevision.assign(value); }
+
+    /**
+     * <p>A string representing the current cluster version.</p>
+     */
+    inline ClusterDbRevision& WithCurrentDatabaseRevision(const Aws::String& value) { SetCurrentDatabaseRevision(value); return *this;}
+
+    /**
+     * <p>A string representing the current cluster version.</p>
+     */
+    inline ClusterDbRevision& WithCurrentDatabaseRevision(Aws::String&& value) { SetCurrentDatabaseRevision(std::move(value)); return *this;}
+
+    /**
+     * <p>A string representing the current cluster version.</p>
+     */
+    inline ClusterDbRevision& WithCurrentDatabaseRevision(const char* value) { SetCurrentDatabaseRevision(value); return *this;}
+
+
+    /**
+     * <p>The date on which the database revision was released.</p>
+     */
+    inline const Aws::Utils::DateTime& GetDatabaseRevisionReleaseDate() const{ return m_databaseRevisionReleaseDate; }
+
+    /**
+     * <p>The date on which the database revision was released.</p>
+     */
+    inline bool DatabaseRevisionReleaseDateHasBeenSet() const { return m_databaseRevisionReleaseDateHasBeenSet; }
+
+    /**
+     * <p>The date on which the database revision was released.</p>
+     */
+    inline void SetDatabaseRevisionReleaseDate(const Aws::Utils::DateTime& value) { m_databaseRevisionReleaseDateHasBeenSet = true; m_databaseRevisionReleaseDate = value; }
+
+    /**
+     * <p>The date on which the database revision was released.</p>
+     */
+    inline void SetDatabaseRevisionReleaseDate(Aws::Utils::DateTime&& value) { m_databaseRevisionReleaseDateHasBeenSet = true; m_databaseRevisionReleaseDate = std::move(value); }
+
+    /**
+     * <p>The date on which the database revision was released.</p>
+     */
+    inline ClusterDbRevision& WithDatabaseRevisionReleaseDate(const Aws::Utils::DateTime& value) { SetDatabaseRevisionReleaseDate(value); return *this;}
+
+    /**
+     * <p>The date on which the database revision was released.</p>
+     */
+    inline ClusterDbRevision& WithDatabaseRevisionReleaseDate(Aws::Utils::DateTime&& value) { SetDatabaseRevisionReleaseDate(std::move(value)); return *this;}
+
+
+    /**
+     * <p>A list of <code>RevisionTarget</code> objects, where each object describes
+     * the database revision that a cluster can be updated to.</p>
+     */
+    inline const Aws::Vector<RevisionTarget>& GetRevisionTargets() const{ return m_revisionTargets; }
+
+    /**
+     * <p>A list of <code>RevisionTarget</code> objects, where each object describes
+     * the database revision that a cluster can be updated to.</p>
+     */
+    inline bool RevisionTargetsHasBeenSet() const { return m_revisionTargetsHasBeenSet; }
+
+    /**
+     * <p>A list of <code>RevisionTarget</code> objects, where each object describes
+     * the database revision that a cluster can be updated to.</p>
+     */
+    inline void SetRevisionTargets(const Aws::Vector<RevisionTarget>& value) { m_revisionTargetsHasBeenSet = true; m_revisionTargets = value; }
+
+    /**
+     * <p>A list of <code>RevisionTarget</code> objects, where each object describes
+     * the database revision that a cluster can be updated to.</p>
+     */
+    inline void SetRevisionTargets(Aws::Vector<RevisionTarget>&& value) { m_revisionTargetsHasBeenSet = true; m_revisionTargets = std::move(value); }
+
+    /**
+     * <p>A list of <code>RevisionTarget</code> objects, where each object describes
+     * the database revision that a cluster can be updated to.</p>
+     */
+    inline ClusterDbRevision& WithRevisionTargets(const Aws::Vector<RevisionTarget>& value) { SetRevisionTargets(value); return *this;}
+
+    /**
+     * <p>A list of <code>RevisionTarget</code> objects, where each object describes
+     * the database revision that a cluster can be updated to.</p>
+     */
+    inline ClusterDbRevision& WithRevisionTargets(Aws::Vector<RevisionTarget>&& value) { SetRevisionTargets(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of <code>RevisionTarget</code> objects, where each object describes
+     * the database revision that a cluster can be updated to.</p>
+     */
+    inline ClusterDbRevision& AddRevisionTargets(const RevisionTarget& value) { m_revisionTargetsHasBeenSet = true; m_revisionTargets.push_back(value); return *this; }
+
+    /**
+     * <p>A list of <code>RevisionTarget</code> objects, where each object describes
+     * the database revision that a cluster can be updated to.</p>
+     */
+    inline ClusterDbRevision& AddRevisionTargets(RevisionTarget&& value) { m_revisionTargetsHasBeenSet = true; m_revisionTargets.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_clusterIdentifier;
+    bool m_clusterIdentifierHasBeenSet;
+
+    Aws::String m_currentDatabaseRevision;
+    bool m_currentDatabaseRevisionHasBeenSet;
+
+    Aws::Utils::DateTime m_databaseRevisionReleaseDate;
+    bool m_databaseRevisionReleaseDateHasBeenSet;
+
+    Aws::Vector<RevisionTarget> m_revisionTargets;
+    bool m_revisionTargetsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/ClusterIamRole.h

@@ -0,0 +1,192 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p>An AWS Identity and Access Management (IAM) role that can be used by the
+   * associated Amazon Redshift cluster to access other AWS services.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/ClusterIamRole">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API ClusterIamRole
+  {
+  public:
+    ClusterIamRole();
+    ClusterIamRole(const Aws::Utils::Xml::XmlNode& xmlNode);
+    ClusterIamRole& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the IAM role, for example,
+     * <code>arn:aws:iam::123456789012:role/RedshiftCopyUnload</code>. </p>
+     */
+    inline const Aws::String& GetIamRoleArn() const{ return m_iamRoleArn; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the IAM role, for example,
+     * <code>arn:aws:iam::123456789012:role/RedshiftCopyUnload</code>. </p>
+     */
+    inline bool IamRoleArnHasBeenSet() const { return m_iamRoleArnHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the IAM role, for example,
+     * <code>arn:aws:iam::123456789012:role/RedshiftCopyUnload</code>. </p>
+     */
+    inline void SetIamRoleArn(const Aws::String& value) { m_iamRoleArnHasBeenSet = true; m_iamRoleArn = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the IAM role, for example,
+     * <code>arn:aws:iam::123456789012:role/RedshiftCopyUnload</code>. </p>
+     */
+    inline void SetIamRoleArn(Aws::String&& value) { m_iamRoleArnHasBeenSet = true; m_iamRoleArn = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the IAM role, for example,
+     * <code>arn:aws:iam::123456789012:role/RedshiftCopyUnload</code>. </p>
+     */
+    inline void SetIamRoleArn(const char* value) { m_iamRoleArnHasBeenSet = true; m_iamRoleArn.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the IAM role, for example,
+     * <code>arn:aws:iam::123456789012:role/RedshiftCopyUnload</code>. </p>
+     */
+    inline ClusterIamRole& WithIamRoleArn(const Aws::String& value) { SetIamRoleArn(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the IAM role, for example,
+     * <code>arn:aws:iam::123456789012:role/RedshiftCopyUnload</code>. </p>
+     */
+    inline ClusterIamRole& WithIamRoleArn(Aws::String&& value) { SetIamRoleArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the IAM role, for example,
+     * <code>arn:aws:iam::123456789012:role/RedshiftCopyUnload</code>. </p>
+     */
+    inline ClusterIamRole& WithIamRoleArn(const char* value) { SetIamRoleArn(value); return *this;}
+
+
+    /**
+     * <p>A value that describes the status of the IAM role's association with an
+     * Amazon Redshift cluster.</p> <p>The following are possible statuses and
+     * descriptions.</p> <ul> <li> <p> <code>in-sync</code>: The role is available for
+     * use by the cluster.</p> </li> <li> <p> <code>adding</code>: The role is in the
+     * process of being associated with the cluster.</p> </li> <li> <p>
+     * <code>removing</code>: The role is in the process of being disassociated with
+     * the cluster.</p> </li> </ul>
+     */
+    inline const Aws::String& GetApplyStatus() const{ return m_applyStatus; }
+
+    /**
+     * <p>A value that describes the status of the IAM role's association with an
+     * Amazon Redshift cluster.</p> <p>The following are possible statuses and
+     * descriptions.</p> <ul> <li> <p> <code>in-sync</code>: The role is available for
+     * use by the cluster.</p> </li> <li> <p> <code>adding</code>: The role is in the
+     * process of being associated with the cluster.</p> </li> <li> <p>
+     * <code>removing</code>: The role is in the process of being disassociated with
+     * the cluster.</p> </li> </ul>
+     */
+    inline bool ApplyStatusHasBeenSet() const { return m_applyStatusHasBeenSet; }
+
+    /**
+     * <p>A value that describes the status of the IAM role's association with an
+     * Amazon Redshift cluster.</p> <p>The following are possible statuses and
+     * descriptions.</p> <ul> <li> <p> <code>in-sync</code>: The role is available for
+     * use by the cluster.</p> </li> <li> <p> <code>adding</code>: The role is in the
+     * process of being associated with the cluster.</p> </li> <li> <p>
+     * <code>removing</code>: The role is in the process of being disassociated with
+     * the cluster.</p> </li> </ul>
+     */
+    inline void SetApplyStatus(const Aws::String& value) { m_applyStatusHasBeenSet = true; m_applyStatus = value; }
+
+    /**
+     * <p>A value that describes the status of the IAM role's association with an
+     * Amazon Redshift cluster.</p> <p>The following are possible statuses and
+     * descriptions.</p> <ul> <li> <p> <code>in-sync</code>: The role is available for
+     * use by the cluster.</p> </li> <li> <p> <code>adding</code>: The role is in the
+     * process of being associated with the cluster.</p> </li> <li> <p>
+     * <code>removing</code>: The role is in the process of being disassociated with
+     * the cluster.</p> </li> </ul>
+     */
+    inline void SetApplyStatus(Aws::String&& value) { m_applyStatusHasBeenSet = true; m_applyStatus = std::move(value); }
+
+    /**
+     * <p>A value that describes the status of the IAM role's association with an
+     * Amazon Redshift cluster.</p> <p>The following are possible statuses and
+     * descriptions.</p> <ul> <li> <p> <code>in-sync</code>: The role is available for
+     * use by the cluster.</p> </li> <li> <p> <code>adding</code>: The role is in the
+     * process of being associated with the cluster.</p> </li> <li> <p>
+     * <code>removing</code>: The role is in the process of being disassociated with
+     * the cluster.</p> </li> </ul>
+     */
+    inline void SetApplyStatus(const char* value) { m_applyStatusHasBeenSet = true; m_applyStatus.assign(value); }
+
+    /**
+     * <p>A value that describes the status of the IAM role's association with an
+     * Amazon Redshift cluster.</p> <p>The following are possible statuses and
+     * descriptions.</p> <ul> <li> <p> <code>in-sync</code>: The role is available for
+     * use by the cluster.</p> </li> <li> <p> <code>adding</code>: The role is in the
+     * process of being associated with the cluster.</p> </li> <li> <p>
+     * <code>removing</code>: The role is in the process of being disassociated with
+     * the cluster.</p> </li> </ul>
+     */
+    inline ClusterIamRole& WithApplyStatus(const Aws::String& value) { SetApplyStatus(value); return *this;}
+
+    /**
+     * <p>A value that describes the status of the IAM role's association with an
+     * Amazon Redshift cluster.</p> <p>The following are possible statuses and
+     * descriptions.</p> <ul> <li> <p> <code>in-sync</code>: The role is available for
+     * use by the cluster.</p> </li> <li> <p> <code>adding</code>: The role is in the
+     * process of being associated with the cluster.</p> </li> <li> <p>
+     * <code>removing</code>: The role is in the process of being disassociated with
+     * the cluster.</p> </li> </ul>
+     */
+    inline ClusterIamRole& WithApplyStatus(Aws::String&& value) { SetApplyStatus(std::move(value)); return *this;}
+
+    /**
+     * <p>A value that describes the status of the IAM role's association with an
+     * Amazon Redshift cluster.</p> <p>The following are possible statuses and
+     * descriptions.</p> <ul> <li> <p> <code>in-sync</code>: The role is available for
+     * use by the cluster.</p> </li> <li> <p> <code>adding</code>: The role is in the
+     * process of being associated with the cluster.</p> </li> <li> <p>
+     * <code>removing</code>: The role is in the process of being disassociated with
+     * the cluster.</p> </li> </ul>
+     */
+    inline ClusterIamRole& WithApplyStatus(const char* value) { SetApplyStatus(value); return *this;}
+
+  private:
+
+    Aws::String m_iamRoleArn;
+    bool m_iamRoleArnHasBeenSet;
+
+    Aws::String m_applyStatus;
+    bool m_applyStatusHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/ClusterNode.h

@@ -0,0 +1,178 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p>The identifier of a node in a cluster.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/ClusterNode">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API ClusterNode
+  {
+  public:
+    ClusterNode();
+    ClusterNode(const Aws::Utils::Xml::XmlNode& xmlNode);
+    ClusterNode& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    /**
+     * <p>Whether the node is a leader node or a compute node.</p>
+     */
+    inline const Aws::String& GetNodeRole() const{ return m_nodeRole; }
+
+    /**
+     * <p>Whether the node is a leader node or a compute node.</p>
+     */
+    inline bool NodeRoleHasBeenSet() const { return m_nodeRoleHasBeenSet; }
+
+    /**
+     * <p>Whether the node is a leader node or a compute node.</p>
+     */
+    inline void SetNodeRole(const Aws::String& value) { m_nodeRoleHasBeenSet = true; m_nodeRole = value; }
+
+    /**
+     * <p>Whether the node is a leader node or a compute node.</p>
+     */
+    inline void SetNodeRole(Aws::String&& value) { m_nodeRoleHasBeenSet = true; m_nodeRole = std::move(value); }
+
+    /**
+     * <p>Whether the node is a leader node or a compute node.</p>
+     */
+    inline void SetNodeRole(const char* value) { m_nodeRoleHasBeenSet = true; m_nodeRole.assign(value); }
+
+    /**
+     * <p>Whether the node is a leader node or a compute node.</p>
+     */
+    inline ClusterNode& WithNodeRole(const Aws::String& value) { SetNodeRole(value); return *this;}
+
+    /**
+     * <p>Whether the node is a leader node or a compute node.</p>
+     */
+    inline ClusterNode& WithNodeRole(Aws::String&& value) { SetNodeRole(std::move(value)); return *this;}
+
+    /**
+     * <p>Whether the node is a leader node or a compute node.</p>
+     */
+    inline ClusterNode& WithNodeRole(const char* value) { SetNodeRole(value); return *this;}
+
+
+    /**
+     * <p>The private IP address of a node within a cluster.</p>
+     */
+    inline const Aws::String& GetPrivateIPAddress() const{ return m_privateIPAddress; }
+
+    /**
+     * <p>The private IP address of a node within a cluster.</p>
+     */
+    inline bool PrivateIPAddressHasBeenSet() const { return m_privateIPAddressHasBeenSet; }
+
+    /**
+     * <p>The private IP address of a node within a cluster.</p>
+     */
+    inline void SetPrivateIPAddress(const Aws::String& value) { m_privateIPAddressHasBeenSet = true; m_privateIPAddress = value; }
+
+    /**
+     * <p>The private IP address of a node within a cluster.</p>
+     */
+    inline void SetPrivateIPAddress(Aws::String&& value) { m_privateIPAddressHasBeenSet = true; m_privateIPAddress = std::move(value); }
+
+    /**
+     * <p>The private IP address of a node within a cluster.</p>
+     */
+    inline void SetPrivateIPAddress(const char* value) { m_privateIPAddressHasBeenSet = true; m_privateIPAddress.assign(value); }
+
+    /**
+     * <p>The private IP address of a node within a cluster.</p>
+     */
+    inline ClusterNode& WithPrivateIPAddress(const Aws::String& value) { SetPrivateIPAddress(value); return *this;}
+
+    /**
+     * <p>The private IP address of a node within a cluster.</p>
+     */
+    inline ClusterNode& WithPrivateIPAddress(Aws::String&& value) { SetPrivateIPAddress(std::move(value)); return *this;}
+
+    /**
+     * <p>The private IP address of a node within a cluster.</p>
+     */
+    inline ClusterNode& WithPrivateIPAddress(const char* value) { SetPrivateIPAddress(value); return *this;}
+
+
+    /**
+     * <p>The public IP address of a node within a cluster.</p>
+     */
+    inline const Aws::String& GetPublicIPAddress() const{ return m_publicIPAddress; }
+
+    /**
+     * <p>The public IP address of a node within a cluster.</p>
+     */
+    inline bool PublicIPAddressHasBeenSet() const { return m_publicIPAddressHasBeenSet; }
+
+    /**
+     * <p>The public IP address of a node within a cluster.</p>
+     */
+    inline void SetPublicIPAddress(const Aws::String& value) { m_publicIPAddressHasBeenSet = true; m_publicIPAddress = value; }
+
+    /**
+     * <p>The public IP address of a node within a cluster.</p>
+     */
+    inline void SetPublicIPAddress(Aws::String&& value) { m_publicIPAddressHasBeenSet = true; m_publicIPAddress = std::move(value); }
+
+    /**
+     * <p>The public IP address of a node within a cluster.</p>
+     */
+    inline void SetPublicIPAddress(const char* value) { m_publicIPAddressHasBeenSet = true; m_publicIPAddress.assign(value); }
+
+    /**
+     * <p>The public IP address of a node within a cluster.</p>
+     */
+    inline ClusterNode& WithPublicIPAddress(const Aws::String& value) { SetPublicIPAddress(value); return *this;}
+
+    /**
+     * <p>The public IP address of a node within a cluster.</p>
+     */
+    inline ClusterNode& WithPublicIPAddress(Aws::String&& value) { SetPublicIPAddress(std::move(value)); return *this;}
+
+    /**
+     * <p>The public IP address of a node within a cluster.</p>
+     */
+    inline ClusterNode& WithPublicIPAddress(const char* value) { SetPublicIPAddress(value); return *this;}
+
+  private:
+
+    Aws::String m_nodeRole;
+    bool m_nodeRoleHasBeenSet;
+
+    Aws::String m_privateIPAddress;
+    bool m_privateIPAddressHasBeenSet;
+
+    Aws::String m_publicIPAddress;
+    bool m_publicIPAddressHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/ClusterParameterGroup.h

@@ -0,0 +1,232 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p>Describes a parameter group.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/ClusterParameterGroup">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API ClusterParameterGroup
+  {
+  public:
+    ClusterParameterGroup();
+    ClusterParameterGroup(const Aws::Utils::Xml::XmlNode& xmlNode);
+    ClusterParameterGroup& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    /**
+     * <p>The name of the cluster parameter group.</p>
+     */
+    inline const Aws::String& GetParameterGroupName() const{ return m_parameterGroupName; }
+
+    /**
+     * <p>The name of the cluster parameter group.</p>
+     */
+    inline bool ParameterGroupNameHasBeenSet() const { return m_parameterGroupNameHasBeenSet; }
+
+    /**
+     * <p>The name of the cluster parameter group.</p>
+     */
+    inline void SetParameterGroupName(const Aws::String& value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName = value; }
+
+    /**
+     * <p>The name of the cluster parameter group.</p>
+     */
+    inline void SetParameterGroupName(Aws::String&& value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName = std::move(value); }
+
+    /**
+     * <p>The name of the cluster parameter group.</p>
+     */
+    inline void SetParameterGroupName(const char* value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName.assign(value); }
+
+    /**
+     * <p>The name of the cluster parameter group.</p>
+     */
+    inline ClusterParameterGroup& WithParameterGroupName(const Aws::String& value) { SetParameterGroupName(value); return *this;}
+
+    /**
+     * <p>The name of the cluster parameter group.</p>
+     */
+    inline ClusterParameterGroup& WithParameterGroupName(Aws::String&& value) { SetParameterGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the cluster parameter group.</p>
+     */
+    inline ClusterParameterGroup& WithParameterGroupName(const char* value) { SetParameterGroupName(value); return *this;}
+
+
+    /**
+     * <p>The name of the cluster parameter group family that this cluster parameter
+     * group is compatible with.</p>
+     */
+    inline const Aws::String& GetParameterGroupFamily() const{ return m_parameterGroupFamily; }
+
+    /**
+     * <p>The name of the cluster parameter group family that this cluster parameter
+     * group is compatible with.</p>
+     */
+    inline bool ParameterGroupFamilyHasBeenSet() const { return m_parameterGroupFamilyHasBeenSet; }
+
+    /**
+     * <p>The name of the cluster parameter group family that this cluster parameter
+     * group is compatible with.</p>
+     */
+    inline void SetParameterGroupFamily(const Aws::String& value) { m_parameterGroupFamilyHasBeenSet = true; m_parameterGroupFamily = value; }
+
+    /**
+     * <p>The name of the cluster parameter group family that this cluster parameter
+     * group is compatible with.</p>
+     */
+    inline void SetParameterGroupFamily(Aws::String&& value) { m_parameterGroupFamilyHasBeenSet = true; m_parameterGroupFamily = std::move(value); }
+
+    /**
+     * <p>The name of the cluster parameter group family that this cluster parameter
+     * group is compatible with.</p>
+     */
+    inline void SetParameterGroupFamily(const char* value) { m_parameterGroupFamilyHasBeenSet = true; m_parameterGroupFamily.assign(value); }
+
+    /**
+     * <p>The name of the cluster parameter group family that this cluster parameter
+     * group is compatible with.</p>
+     */
+    inline ClusterParameterGroup& WithParameterGroupFamily(const Aws::String& value) { SetParameterGroupFamily(value); return *this;}
+
+    /**
+     * <p>The name of the cluster parameter group family that this cluster parameter
+     * group is compatible with.</p>
+     */
+    inline ClusterParameterGroup& WithParameterGroupFamily(Aws::String&& value) { SetParameterGroupFamily(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the cluster parameter group family that this cluster parameter
+     * group is compatible with.</p>
+     */
+    inline ClusterParameterGroup& WithParameterGroupFamily(const char* value) { SetParameterGroupFamily(value); return *this;}
+
+
+    /**
+     * <p>The description of the parameter group.</p>
+     */
+    inline const Aws::String& GetDescription() const{ return m_description; }
+
+    /**
+     * <p>The description of the parameter group.</p>
+     */
+    inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
+
+    /**
+     * <p>The description of the parameter group.</p>
+     */
+    inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
+
+    /**
+     * <p>The description of the parameter group.</p>
+     */
+    inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
+
+    /**
+     * <p>The description of the parameter group.</p>
+     */
+    inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
+
+    /**
+     * <p>The description of the parameter group.</p>
+     */
+    inline ClusterParameterGroup& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
+
+    /**
+     * <p>The description of the parameter group.</p>
+     */
+    inline ClusterParameterGroup& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
+
+    /**
+     * <p>The description of the parameter group.</p>
+     */
+    inline ClusterParameterGroup& WithDescription(const char* value) { SetDescription(value); return *this;}
+
+
+    /**
+     * <p>The list of tags for the cluster parameter group.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>The list of tags for the cluster parameter group.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>The list of tags for the cluster parameter group.</p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>The list of tags for the cluster parameter group.</p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>The list of tags for the cluster parameter group.</p>
+     */
+    inline ClusterParameterGroup& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>The list of tags for the cluster parameter group.</p>
+     */
+    inline ClusterParameterGroup& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>The list of tags for the cluster parameter group.</p>
+     */
+    inline ClusterParameterGroup& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>The list of tags for the cluster parameter group.</p>
+     */
+    inline ClusterParameterGroup& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_parameterGroupName;
+    bool m_parameterGroupNameHasBeenSet;
+
+    Aws::String m_parameterGroupFamily;
+    bool m_parameterGroupFamilyHasBeenSet;
+
+    Aws::String m_description;
+    bool m_descriptionHasBeenSet;
+
+    Aws::Vector<Tag> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/ClusterParameterGroupStatus.h

@@ -0,0 +1,212 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/ClusterParameterStatus.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p>Describes the status of a parameter group.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/ClusterParameterGroupStatus">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API ClusterParameterGroupStatus
+  {
+  public:
+    ClusterParameterGroupStatus();
+    ClusterParameterGroupStatus(const Aws::Utils::Xml::XmlNode& xmlNode);
+    ClusterParameterGroupStatus& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    /**
+     * <p>The name of the cluster parameter group.</p>
+     */
+    inline const Aws::String& GetParameterGroupName() const{ return m_parameterGroupName; }
+
+    /**
+     * <p>The name of the cluster parameter group.</p>
+     */
+    inline bool ParameterGroupNameHasBeenSet() const { return m_parameterGroupNameHasBeenSet; }
+
+    /**
+     * <p>The name of the cluster parameter group.</p>
+     */
+    inline void SetParameterGroupName(const Aws::String& value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName = value; }
+
+    /**
+     * <p>The name of the cluster parameter group.</p>
+     */
+    inline void SetParameterGroupName(Aws::String&& value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName = std::move(value); }
+
+    /**
+     * <p>The name of the cluster parameter group.</p>
+     */
+    inline void SetParameterGroupName(const char* value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName.assign(value); }
+
+    /**
+     * <p>The name of the cluster parameter group.</p>
+     */
+    inline ClusterParameterGroupStatus& WithParameterGroupName(const Aws::String& value) { SetParameterGroupName(value); return *this;}
+
+    /**
+     * <p>The name of the cluster parameter group.</p>
+     */
+    inline ClusterParameterGroupStatus& WithParameterGroupName(Aws::String&& value) { SetParameterGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the cluster parameter group.</p>
+     */
+    inline ClusterParameterGroupStatus& 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 ClusterParameterGroupStatus& WithParameterApplyStatus(const Aws::String& value) { SetParameterApplyStatus(value); return *this;}
+
+    /**
+     * <p>The status of parameter updates.</p>
+     */
+    inline ClusterParameterGroupStatus& WithParameterApplyStatus(Aws::String&& value) { SetParameterApplyStatus(std::move(value)); return *this;}
+
+    /**
+     * <p>The status of parameter updates.</p>
+     */
+    inline ClusterParameterGroupStatus& WithParameterApplyStatus(const char* value) { SetParameterApplyStatus(value); return *this;}
+
+
+    /**
+     * <p>The list of parameter statuses.</p> <p> For more information about parameters
+     * and parameter groups, go to <a
+     * href="https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-parameter-groups.html">Amazon
+     * Redshift Parameter Groups</a> in the <i>Amazon Redshift Cluster Management
+     * Guide</i>.</p>
+     */
+    inline const Aws::Vector<ClusterParameterStatus>& GetClusterParameterStatusList() const{ return m_clusterParameterStatusList; }
+
+    /**
+     * <p>The list of parameter statuses.</p> <p> For more information about parameters
+     * and parameter groups, go to <a
+     * href="https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-parameter-groups.html">Amazon
+     * Redshift Parameter Groups</a> in the <i>Amazon Redshift Cluster Management
+     * Guide</i>.</p>
+     */
+    inline bool ClusterParameterStatusListHasBeenSet() const { return m_clusterParameterStatusListHasBeenSet; }
+
+    /**
+     * <p>The list of parameter statuses.</p> <p> For more information about parameters
+     * and parameter groups, go to <a
+     * href="https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-parameter-groups.html">Amazon
+     * Redshift Parameter Groups</a> in the <i>Amazon Redshift Cluster Management
+     * Guide</i>.</p>
+     */
+    inline void SetClusterParameterStatusList(const Aws::Vector<ClusterParameterStatus>& value) { m_clusterParameterStatusListHasBeenSet = true; m_clusterParameterStatusList = value; }
+
+    /**
+     * <p>The list of parameter statuses.</p> <p> For more information about parameters
+     * and parameter groups, go to <a
+     * href="https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-parameter-groups.html">Amazon
+     * Redshift Parameter Groups</a> in the <i>Amazon Redshift Cluster Management
+     * Guide</i>.</p>
+     */
+    inline void SetClusterParameterStatusList(Aws::Vector<ClusterParameterStatus>&& value) { m_clusterParameterStatusListHasBeenSet = true; m_clusterParameterStatusList = std::move(value); }
+
+    /**
+     * <p>The list of parameter statuses.</p> <p> For more information about parameters
+     * and parameter groups, go to <a
+     * href="https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-parameter-groups.html">Amazon
+     * Redshift Parameter Groups</a> in the <i>Amazon Redshift Cluster Management
+     * Guide</i>.</p>
+     */
+    inline ClusterParameterGroupStatus& WithClusterParameterStatusList(const Aws::Vector<ClusterParameterStatus>& value) { SetClusterParameterStatusList(value); return *this;}
+
+    /**
+     * <p>The list of parameter statuses.</p> <p> For more information about parameters
+     * and parameter groups, go to <a
+     * href="https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-parameter-groups.html">Amazon
+     * Redshift Parameter Groups</a> in the <i>Amazon Redshift Cluster Management
+     * Guide</i>.</p>
+     */
+    inline ClusterParameterGroupStatus& WithClusterParameterStatusList(Aws::Vector<ClusterParameterStatus>&& value) { SetClusterParameterStatusList(std::move(value)); return *this;}
+
+    /**
+     * <p>The list of parameter statuses.</p> <p> For more information about parameters
+     * and parameter groups, go to <a
+     * href="https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-parameter-groups.html">Amazon
+     * Redshift Parameter Groups</a> in the <i>Amazon Redshift Cluster Management
+     * Guide</i>.</p>
+     */
+    inline ClusterParameterGroupStatus& AddClusterParameterStatusList(const ClusterParameterStatus& value) { m_clusterParameterStatusListHasBeenSet = true; m_clusterParameterStatusList.push_back(value); return *this; }
+
+    /**
+     * <p>The list of parameter statuses.</p> <p> For more information about parameters
+     * and parameter groups, go to <a
+     * href="https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-parameter-groups.html">Amazon
+     * Redshift Parameter Groups</a> in the <i>Amazon Redshift Cluster Management
+     * Guide</i>.</p>
+     */
+    inline ClusterParameterGroupStatus& AddClusterParameterStatusList(ClusterParameterStatus&& value) { m_clusterParameterStatusListHasBeenSet = true; m_clusterParameterStatusList.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_parameterGroupName;
+    bool m_parameterGroupNameHasBeenSet;
+
+    Aws::String m_parameterApplyStatus;
+    bool m_parameterApplyStatusHasBeenSet;
+
+    Aws::Vector<ClusterParameterStatus> m_clusterParameterStatusList;
+    bool m_clusterParameterStatusListHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/ClusterParameterStatus.h

@@ -0,0 +1,298 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p>Describes the status of a parameter group.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/ClusterParameterStatus">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API ClusterParameterStatus
+  {
+  public:
+    ClusterParameterStatus();
+    ClusterParameterStatus(const Aws::Utils::Xml::XmlNode& xmlNode);
+    ClusterParameterStatus& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    /**
+     * <p>The name of the 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 ClusterParameterStatus& WithParameterName(const Aws::String& value) { SetParameterName(value); return *this;}
+
+    /**
+     * <p>The name of the parameter.</p>
+     */
+    inline ClusterParameterStatus& WithParameterName(Aws::String&& value) { SetParameterName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the parameter.</p>
+     */
+    inline ClusterParameterStatus& WithParameterName(const char* value) { SetParameterName(value); return *this;}
+
+
+    /**
+     * <p>The status of the parameter that indicates whether the parameter is in sync
+     * with the database, waiting for a cluster reboot, or encountered an error when
+     * being applied.</p> <p>The following are possible statuses and descriptions.</p>
+     * <ul> <li> <p> <code>in-sync</code>: The parameter value is in sync with the
+     * database.</p> </li> <li> <p> <code>pending-reboot</code>: The parameter value
+     * will be applied after the cluster reboots.</p> </li> <li> <p>
+     * <code>applying</code>: The parameter value is being applied to the database.</p>
+     * </li> <li> <p> <code>invalid-parameter</code>: Cannot apply the parameter value
+     * because it has an invalid value or syntax.</p> </li> <li> <p>
+     * <code>apply-deferred</code>: The parameter contains static property changes. The
+     * changes are deferred until the cluster reboots.</p> </li> <li> <p>
+     * <code>apply-error</code>: Cannot connect to the cluster. The parameter change
+     * will be applied after the cluster reboots.</p> </li> <li> <p>
+     * <code>unknown-error</code>: Cannot apply the parameter change right now. The
+     * change will be applied after the cluster reboots.</p> </li> </ul>
+     */
+    inline const Aws::String& GetParameterApplyStatus() const{ return m_parameterApplyStatus; }
+
+    /**
+     * <p>The status of the parameter that indicates whether the parameter is in sync
+     * with the database, waiting for a cluster reboot, or encountered an error when
+     * being applied.</p> <p>The following are possible statuses and descriptions.</p>
+     * <ul> <li> <p> <code>in-sync</code>: The parameter value is in sync with the
+     * database.</p> </li> <li> <p> <code>pending-reboot</code>: The parameter value
+     * will be applied after the cluster reboots.</p> </li> <li> <p>
+     * <code>applying</code>: The parameter value is being applied to the database.</p>
+     * </li> <li> <p> <code>invalid-parameter</code>: Cannot apply the parameter value
+     * because it has an invalid value or syntax.</p> </li> <li> <p>
+     * <code>apply-deferred</code>: The parameter contains static property changes. The
+     * changes are deferred until the cluster reboots.</p> </li> <li> <p>
+     * <code>apply-error</code>: Cannot connect to the cluster. The parameter change
+     * will be applied after the cluster reboots.</p> </li> <li> <p>
+     * <code>unknown-error</code>: Cannot apply the parameter change right now. The
+     * change will be applied after the cluster reboots.</p> </li> </ul>
+     */
+    inline bool ParameterApplyStatusHasBeenSet() const { return m_parameterApplyStatusHasBeenSet; }
+
+    /**
+     * <p>The status of the parameter that indicates whether the parameter is in sync
+     * with the database, waiting for a cluster reboot, or encountered an error when
+     * being applied.</p> <p>The following are possible statuses and descriptions.</p>
+     * <ul> <li> <p> <code>in-sync</code>: The parameter value is in sync with the
+     * database.</p> </li> <li> <p> <code>pending-reboot</code>: The parameter value
+     * will be applied after the cluster reboots.</p> </li> <li> <p>
+     * <code>applying</code>: The parameter value is being applied to the database.</p>
+     * </li> <li> <p> <code>invalid-parameter</code>: Cannot apply the parameter value
+     * because it has an invalid value or syntax.</p> </li> <li> <p>
+     * <code>apply-deferred</code>: The parameter contains static property changes. The
+     * changes are deferred until the cluster reboots.</p> </li> <li> <p>
+     * <code>apply-error</code>: Cannot connect to the cluster. The parameter change
+     * will be applied after the cluster reboots.</p> </li> <li> <p>
+     * <code>unknown-error</code>: Cannot apply the parameter change right now. The
+     * change will be applied after the cluster reboots.</p> </li> </ul>
+     */
+    inline void SetParameterApplyStatus(const Aws::String& value) { m_parameterApplyStatusHasBeenSet = true; m_parameterApplyStatus = value; }
+
+    /**
+     * <p>The status of the parameter that indicates whether the parameter is in sync
+     * with the database, waiting for a cluster reboot, or encountered an error when
+     * being applied.</p> <p>The following are possible statuses and descriptions.</p>
+     * <ul> <li> <p> <code>in-sync</code>: The parameter value is in sync with the
+     * database.</p> </li> <li> <p> <code>pending-reboot</code>: The parameter value
+     * will be applied after the cluster reboots.</p> </li> <li> <p>
+     * <code>applying</code>: The parameter value is being applied to the database.</p>
+     * </li> <li> <p> <code>invalid-parameter</code>: Cannot apply the parameter value
+     * because it has an invalid value or syntax.</p> </li> <li> <p>
+     * <code>apply-deferred</code>: The parameter contains static property changes. The
+     * changes are deferred until the cluster reboots.</p> </li> <li> <p>
+     * <code>apply-error</code>: Cannot connect to the cluster. The parameter change
+     * will be applied after the cluster reboots.</p> </li> <li> <p>
+     * <code>unknown-error</code>: Cannot apply the parameter change right now. The
+     * change will be applied after the cluster reboots.</p> </li> </ul>
+     */
+    inline void SetParameterApplyStatus(Aws::String&& value) { m_parameterApplyStatusHasBeenSet = true; m_parameterApplyStatus = std::move(value); }
+
+    /**
+     * <p>The status of the parameter that indicates whether the parameter is in sync
+     * with the database, waiting for a cluster reboot, or encountered an error when
+     * being applied.</p> <p>The following are possible statuses and descriptions.</p>
+     * <ul> <li> <p> <code>in-sync</code>: The parameter value is in sync with the
+     * database.</p> </li> <li> <p> <code>pending-reboot</code>: The parameter value
+     * will be applied after the cluster reboots.</p> </li> <li> <p>
+     * <code>applying</code>: The parameter value is being applied to the database.</p>
+     * </li> <li> <p> <code>invalid-parameter</code>: Cannot apply the parameter value
+     * because it has an invalid value or syntax.</p> </li> <li> <p>
+     * <code>apply-deferred</code>: The parameter contains static property changes. The
+     * changes are deferred until the cluster reboots.</p> </li> <li> <p>
+     * <code>apply-error</code>: Cannot connect to the cluster. The parameter change
+     * will be applied after the cluster reboots.</p> </li> <li> <p>
+     * <code>unknown-error</code>: Cannot apply the parameter change right now. The
+     * change will be applied after the cluster reboots.</p> </li> </ul>
+     */
+    inline void SetParameterApplyStatus(const char* value) { m_parameterApplyStatusHasBeenSet = true; m_parameterApplyStatus.assign(value); }
+
+    /**
+     * <p>The status of the parameter that indicates whether the parameter is in sync
+     * with the database, waiting for a cluster reboot, or encountered an error when
+     * being applied.</p> <p>The following are possible statuses and descriptions.</p>
+     * <ul> <li> <p> <code>in-sync</code>: The parameter value is in sync with the
+     * database.</p> </li> <li> <p> <code>pending-reboot</code>: The parameter value
+     * will be applied after the cluster reboots.</p> </li> <li> <p>
+     * <code>applying</code>: The parameter value is being applied to the database.</p>
+     * </li> <li> <p> <code>invalid-parameter</code>: Cannot apply the parameter value
+     * because it has an invalid value or syntax.</p> </li> <li> <p>
+     * <code>apply-deferred</code>: The parameter contains static property changes. The
+     * changes are deferred until the cluster reboots.</p> </li> <li> <p>
+     * <code>apply-error</code>: Cannot connect to the cluster. The parameter change
+     * will be applied after the cluster reboots.</p> </li> <li> <p>
+     * <code>unknown-error</code>: Cannot apply the parameter change right now. The
+     * change will be applied after the cluster reboots.</p> </li> </ul>
+     */
+    inline ClusterParameterStatus& WithParameterApplyStatus(const Aws::String& value) { SetParameterApplyStatus(value); return *this;}
+
+    /**
+     * <p>The status of the parameter that indicates whether the parameter is in sync
+     * with the database, waiting for a cluster reboot, or encountered an error when
+     * being applied.</p> <p>The following are possible statuses and descriptions.</p>
+     * <ul> <li> <p> <code>in-sync</code>: The parameter value is in sync with the
+     * database.</p> </li> <li> <p> <code>pending-reboot</code>: The parameter value
+     * will be applied after the cluster reboots.</p> </li> <li> <p>
+     * <code>applying</code>: The parameter value is being applied to the database.</p>
+     * </li> <li> <p> <code>invalid-parameter</code>: Cannot apply the parameter value
+     * because it has an invalid value or syntax.</p> </li> <li> <p>
+     * <code>apply-deferred</code>: The parameter contains static property changes. The
+     * changes are deferred until the cluster reboots.</p> </li> <li> <p>
+     * <code>apply-error</code>: Cannot connect to the cluster. The parameter change
+     * will be applied after the cluster reboots.</p> </li> <li> <p>
+     * <code>unknown-error</code>: Cannot apply the parameter change right now. The
+     * change will be applied after the cluster reboots.</p> </li> </ul>
+     */
+    inline ClusterParameterStatus& WithParameterApplyStatus(Aws::String&& value) { SetParameterApplyStatus(std::move(value)); return *this;}
+
+    /**
+     * <p>The status of the parameter that indicates whether the parameter is in sync
+     * with the database, waiting for a cluster reboot, or encountered an error when
+     * being applied.</p> <p>The following are possible statuses and descriptions.</p>
+     * <ul> <li> <p> <code>in-sync</code>: The parameter value is in sync with the
+     * database.</p> </li> <li> <p> <code>pending-reboot</code>: The parameter value
+     * will be applied after the cluster reboots.</p> </li> <li> <p>
+     * <code>applying</code>: The parameter value is being applied to the database.</p>
+     * </li> <li> <p> <code>invalid-parameter</code>: Cannot apply the parameter value
+     * because it has an invalid value or syntax.</p> </li> <li> <p>
+     * <code>apply-deferred</code>: The parameter contains static property changes. The
+     * changes are deferred until the cluster reboots.</p> </li> <li> <p>
+     * <code>apply-error</code>: Cannot connect to the cluster. The parameter change
+     * will be applied after the cluster reboots.</p> </li> <li> <p>
+     * <code>unknown-error</code>: Cannot apply the parameter change right now. The
+     * change will be applied after the cluster reboots.</p> </li> </ul>
+     */
+    inline ClusterParameterStatus& WithParameterApplyStatus(const char* value) { SetParameterApplyStatus(value); return *this;}
+
+
+    /**
+     * <p>The error that prevented the parameter from being applied to the
+     * database.</p>
+     */
+    inline const Aws::String& GetParameterApplyErrorDescription() const{ return m_parameterApplyErrorDescription; }
+
+    /**
+     * <p>The error that prevented the parameter from being applied to the
+     * database.</p>
+     */
+    inline bool ParameterApplyErrorDescriptionHasBeenSet() const { return m_parameterApplyErrorDescriptionHasBeenSet; }
+
+    /**
+     * <p>The error that prevented the parameter from being applied to the
+     * database.</p>
+     */
+    inline void SetParameterApplyErrorDescription(const Aws::String& value) { m_parameterApplyErrorDescriptionHasBeenSet = true; m_parameterApplyErrorDescription = value; }
+
+    /**
+     * <p>The error that prevented the parameter from being applied to the
+     * database.</p>
+     */
+    inline void SetParameterApplyErrorDescription(Aws::String&& value) { m_parameterApplyErrorDescriptionHasBeenSet = true; m_parameterApplyErrorDescription = std::move(value); }
+
+    /**
+     * <p>The error that prevented the parameter from being applied to the
+     * database.</p>
+     */
+    inline void SetParameterApplyErrorDescription(const char* value) { m_parameterApplyErrorDescriptionHasBeenSet = true; m_parameterApplyErrorDescription.assign(value); }
+
+    /**
+     * <p>The error that prevented the parameter from being applied to the
+     * database.</p>
+     */
+    inline ClusterParameterStatus& WithParameterApplyErrorDescription(const Aws::String& value) { SetParameterApplyErrorDescription(value); return *this;}
+
+    /**
+     * <p>The error that prevented the parameter from being applied to the
+     * database.</p>
+     */
+    inline ClusterParameterStatus& WithParameterApplyErrorDescription(Aws::String&& value) { SetParameterApplyErrorDescription(std::move(value)); return *this;}
+
+    /**
+     * <p>The error that prevented the parameter from being applied to the
+     * database.</p>
+     */
+    inline ClusterParameterStatus& WithParameterApplyErrorDescription(const char* value) { SetParameterApplyErrorDescription(value); return *this;}
+
+  private:
+
+    Aws::String m_parameterName;
+    bool m_parameterNameHasBeenSet;
+
+    Aws::String m_parameterApplyStatus;
+    bool m_parameterApplyStatusHasBeenSet;
+
+    Aws::String m_parameterApplyErrorDescription;
+    bool m_parameterApplyErrorDescriptionHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/ClusterSecurityGroup.h

@@ -0,0 +1,294 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/EC2SecurityGroup.h>
+#include <aws/redshift/model/IPRange.h>
+#include <aws/redshift/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p>Describes a security group.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/ClusterSecurityGroup">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API ClusterSecurityGroup
+  {
+  public:
+    ClusterSecurityGroup();
+    ClusterSecurityGroup(const Aws::Utils::Xml::XmlNode& xmlNode);
+    ClusterSecurityGroup& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    /**
+     * <p>The name of the cluster security group to which the operation was
+     * applied.</p>
+     */
+    inline const Aws::String& GetClusterSecurityGroupName() const{ return m_clusterSecurityGroupName; }
+
+    /**
+     * <p>The name of the cluster security group to which the operation was
+     * applied.</p>
+     */
+    inline bool ClusterSecurityGroupNameHasBeenSet() const { return m_clusterSecurityGroupNameHasBeenSet; }
+
+    /**
+     * <p>The name of the cluster security group to which the operation was
+     * applied.</p>
+     */
+    inline void SetClusterSecurityGroupName(const Aws::String& value) { m_clusterSecurityGroupNameHasBeenSet = true; m_clusterSecurityGroupName = value; }
+
+    /**
+     * <p>The name of the cluster security group to which the operation was
+     * applied.</p>
+     */
+    inline void SetClusterSecurityGroupName(Aws::String&& value) { m_clusterSecurityGroupNameHasBeenSet = true; m_clusterSecurityGroupName = std::move(value); }
+
+    /**
+     * <p>The name of the cluster security group to which the operation was
+     * applied.</p>
+     */
+    inline void SetClusterSecurityGroupName(const char* value) { m_clusterSecurityGroupNameHasBeenSet = true; m_clusterSecurityGroupName.assign(value); }
+
+    /**
+     * <p>The name of the cluster security group to which the operation was
+     * applied.</p>
+     */
+    inline ClusterSecurityGroup& WithClusterSecurityGroupName(const Aws::String& value) { SetClusterSecurityGroupName(value); return *this;}
+
+    /**
+     * <p>The name of the cluster security group to which the operation was
+     * applied.</p>
+     */
+    inline ClusterSecurityGroup& WithClusterSecurityGroupName(Aws::String&& value) { SetClusterSecurityGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the cluster security group to which the operation was
+     * applied.</p>
+     */
+    inline ClusterSecurityGroup& WithClusterSecurityGroupName(const char* value) { SetClusterSecurityGroupName(value); return *this;}
+
+
+    /**
+     * <p>A description of the security group.</p>
+     */
+    inline const Aws::String& GetDescription() const{ return m_description; }
+
+    /**
+     * <p>A description of the security group.</p>
+     */
+    inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
+
+    /**
+     * <p>A description of the security group.</p>
+     */
+    inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
+
+    /**
+     * <p>A description of the security group.</p>
+     */
+    inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
+
+    /**
+     * <p>A description of the security group.</p>
+     */
+    inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
+
+    /**
+     * <p>A description of the security group.</p>
+     */
+    inline ClusterSecurityGroup& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
+
+    /**
+     * <p>A description of the security group.</p>
+     */
+    inline ClusterSecurityGroup& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
+
+    /**
+     * <p>A description of the security group.</p>
+     */
+    inline ClusterSecurityGroup& WithDescription(const char* value) { SetDescription(value); return *this;}
+
+
+    /**
+     * <p>A list of EC2 security groups that are permitted to access clusters
+     * associated with this cluster security group.</p>
+     */
+    inline const Aws::Vector<EC2SecurityGroup>& GetEC2SecurityGroups() const{ return m_eC2SecurityGroups; }
+
+    /**
+     * <p>A list of EC2 security groups that are permitted to access clusters
+     * associated with this cluster security group.</p>
+     */
+    inline bool EC2SecurityGroupsHasBeenSet() const { return m_eC2SecurityGroupsHasBeenSet; }
+
+    /**
+     * <p>A list of EC2 security groups that are permitted to access clusters
+     * associated with this cluster security group.</p>
+     */
+    inline void SetEC2SecurityGroups(const Aws::Vector<EC2SecurityGroup>& value) { m_eC2SecurityGroupsHasBeenSet = true; m_eC2SecurityGroups = value; }
+
+    /**
+     * <p>A list of EC2 security groups that are permitted to access clusters
+     * associated with this cluster security group.</p>
+     */
+    inline void SetEC2SecurityGroups(Aws::Vector<EC2SecurityGroup>&& value) { m_eC2SecurityGroupsHasBeenSet = true; m_eC2SecurityGroups = std::move(value); }
+
+    /**
+     * <p>A list of EC2 security groups that are permitted to access clusters
+     * associated with this cluster security group.</p>
+     */
+    inline ClusterSecurityGroup& WithEC2SecurityGroups(const Aws::Vector<EC2SecurityGroup>& value) { SetEC2SecurityGroups(value); return *this;}
+
+    /**
+     * <p>A list of EC2 security groups that are permitted to access clusters
+     * associated with this cluster security group.</p>
+     */
+    inline ClusterSecurityGroup& WithEC2SecurityGroups(Aws::Vector<EC2SecurityGroup>&& value) { SetEC2SecurityGroups(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of EC2 security groups that are permitted to access clusters
+     * associated with this cluster security group.</p>
+     */
+    inline ClusterSecurityGroup& AddEC2SecurityGroups(const EC2SecurityGroup& value) { m_eC2SecurityGroupsHasBeenSet = true; m_eC2SecurityGroups.push_back(value); return *this; }
+
+    /**
+     * <p>A list of EC2 security groups that are permitted to access clusters
+     * associated with this cluster security group.</p>
+     */
+    inline ClusterSecurityGroup& AddEC2SecurityGroups(EC2SecurityGroup&& value) { m_eC2SecurityGroupsHasBeenSet = true; m_eC2SecurityGroups.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>A list of IP ranges (CIDR blocks) that are permitted to access clusters
+     * associated with this cluster security group.</p>
+     */
+    inline const Aws::Vector<IPRange>& GetIPRanges() const{ return m_iPRanges; }
+
+    /**
+     * <p>A list of IP ranges (CIDR blocks) that are permitted to access clusters
+     * associated with this cluster security group.</p>
+     */
+    inline bool IPRangesHasBeenSet() const { return m_iPRangesHasBeenSet; }
+
+    /**
+     * <p>A list of IP ranges (CIDR blocks) that are permitted to access clusters
+     * associated with this cluster security group.</p>
+     */
+    inline void SetIPRanges(const Aws::Vector<IPRange>& value) { m_iPRangesHasBeenSet = true; m_iPRanges = value; }
+
+    /**
+     * <p>A list of IP ranges (CIDR blocks) that are permitted to access clusters
+     * associated with this cluster security group.</p>
+     */
+    inline void SetIPRanges(Aws::Vector<IPRange>&& value) { m_iPRangesHasBeenSet = true; m_iPRanges = std::move(value); }
+
+    /**
+     * <p>A list of IP ranges (CIDR blocks) that are permitted to access clusters
+     * associated with this cluster security group.</p>
+     */
+    inline ClusterSecurityGroup& WithIPRanges(const Aws::Vector<IPRange>& value) { SetIPRanges(value); return *this;}
+
+    /**
+     * <p>A list of IP ranges (CIDR blocks) that are permitted to access clusters
+     * associated with this cluster security group.</p>
+     */
+    inline ClusterSecurityGroup& WithIPRanges(Aws::Vector<IPRange>&& value) { SetIPRanges(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of IP ranges (CIDR blocks) that are permitted to access clusters
+     * associated with this cluster security group.</p>
+     */
+    inline ClusterSecurityGroup& AddIPRanges(const IPRange& value) { m_iPRangesHasBeenSet = true; m_iPRanges.push_back(value); return *this; }
+
+    /**
+     * <p>A list of IP ranges (CIDR blocks) that are permitted to access clusters
+     * associated with this cluster security group.</p>
+     */
+    inline ClusterSecurityGroup& AddIPRanges(IPRange&& value) { m_iPRangesHasBeenSet = true; m_iPRanges.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>The list of tags for the cluster security group.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>The list of tags for the cluster security group.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>The list of tags for the cluster security group.</p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>The list of tags for the cluster security group.</p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>The list of tags for the cluster security group.</p>
+     */
+    inline ClusterSecurityGroup& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>The list of tags for the cluster security group.</p>
+     */
+    inline ClusterSecurityGroup& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>The list of tags for the cluster security group.</p>
+     */
+    inline ClusterSecurityGroup& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>The list of tags for the cluster security group.</p>
+     */
+    inline ClusterSecurityGroup& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_clusterSecurityGroupName;
+    bool m_clusterSecurityGroupNameHasBeenSet;
+
+    Aws::String m_description;
+    bool m_descriptionHasBeenSet;
+
+    Aws::Vector<EC2SecurityGroup> m_eC2SecurityGroups;
+    bool m_eC2SecurityGroupsHasBeenSet;
+
+    Aws::Vector<IPRange> m_iPRanges;
+    bool m_iPRangesHasBeenSet;
+
+    Aws::Vector<Tag> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/ClusterSecurityGroupMembership.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/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p>Describes a cluster security group.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/ClusterSecurityGroupMembership">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API ClusterSecurityGroupMembership
+  {
+  public:
+    ClusterSecurityGroupMembership();
+    ClusterSecurityGroupMembership(const Aws::Utils::Xml::XmlNode& xmlNode);
+    ClusterSecurityGroupMembership& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    /**
+     * <p>The name of the cluster security group.</p>
+     */
+    inline const Aws::String& GetClusterSecurityGroupName() const{ return m_clusterSecurityGroupName; }
+
+    /**
+     * <p>The name of the cluster security group.</p>
+     */
+    inline bool ClusterSecurityGroupNameHasBeenSet() const { return m_clusterSecurityGroupNameHasBeenSet; }
+
+    /**
+     * <p>The name of the cluster security group.</p>
+     */
+    inline void SetClusterSecurityGroupName(const Aws::String& value) { m_clusterSecurityGroupNameHasBeenSet = true; m_clusterSecurityGroupName = value; }
+
+    /**
+     * <p>The name of the cluster security group.</p>
+     */
+    inline void SetClusterSecurityGroupName(Aws::String&& value) { m_clusterSecurityGroupNameHasBeenSet = true; m_clusterSecurityGroupName = std::move(value); }
+
+    /**
+     * <p>The name of the cluster security group.</p>
+     */
+    inline void SetClusterSecurityGroupName(const char* value) { m_clusterSecurityGroupNameHasBeenSet = true; m_clusterSecurityGroupName.assign(value); }
+
+    /**
+     * <p>The name of the cluster security group.</p>
+     */
+    inline ClusterSecurityGroupMembership& WithClusterSecurityGroupName(const Aws::String& value) { SetClusterSecurityGroupName(value); return *this;}
+
+    /**
+     * <p>The name of the cluster security group.</p>
+     */
+    inline ClusterSecurityGroupMembership& WithClusterSecurityGroupName(Aws::String&& value) { SetClusterSecurityGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the cluster security group.</p>
+     */
+    inline ClusterSecurityGroupMembership& WithClusterSecurityGroupName(const char* value) { SetClusterSecurityGroupName(value); return *this;}
+
+
+    /**
+     * <p>The status of the cluster security group.</p>
+     */
+    inline const Aws::String& GetStatus() const{ return m_status; }
+
+    /**
+     * <p>The status of the cluster security group.</p>
+     */
+    inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
+
+    /**
+     * <p>The status of the cluster security group.</p>
+     */
+    inline void SetStatus(const Aws::String& value) { m_statusHasBeenSet = true; m_status = value; }
+
+    /**
+     * <p>The status of the cluster security group.</p>
+     */
+    inline void SetStatus(Aws::String&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }
+
+    /**
+     * <p>The status of the cluster security group.</p>
+     */
+    inline void SetStatus(const char* value) { m_statusHasBeenSet = true; m_status.assign(value); }
+
+    /**
+     * <p>The status of the cluster security group.</p>
+     */
+    inline ClusterSecurityGroupMembership& WithStatus(const Aws::String& value) { SetStatus(value); return *this;}
+
+    /**
+     * <p>The status of the cluster security group.</p>
+     */
+    inline ClusterSecurityGroupMembership& WithStatus(Aws::String&& value) { SetStatus(std::move(value)); return *this;}
+
+    /**
+     * <p>The status of the cluster security group.</p>
+     */
+    inline ClusterSecurityGroupMembership& WithStatus(const char* value) { SetStatus(value); return *this;}
+
+  private:
+
+    Aws::String m_clusterSecurityGroupName;
+    bool m_clusterSecurityGroupNameHasBeenSet;
+
+    Aws::String m_status;
+    bool m_statusHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/ClusterSnapshotCopyStatus.h

@@ -0,0 +1,207 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p>Returns the destination region and retention period that are configured for
+   * cross-region snapshot copy.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/ClusterSnapshotCopyStatus">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API ClusterSnapshotCopyStatus
+  {
+  public:
+    ClusterSnapshotCopyStatus();
+    ClusterSnapshotCopyStatus(const Aws::Utils::Xml::XmlNode& xmlNode);
+    ClusterSnapshotCopyStatus& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    /**
+     * <p>The destination region that snapshots are automatically copied to when
+     * cross-region snapshot copy is enabled.</p>
+     */
+    inline const Aws::String& GetDestinationRegion() const{ return m_destinationRegion; }
+
+    /**
+     * <p>The destination region that snapshots are automatically copied to when
+     * cross-region snapshot copy is enabled.</p>
+     */
+    inline bool DestinationRegionHasBeenSet() const { return m_destinationRegionHasBeenSet; }
+
+    /**
+     * <p>The destination region that snapshots are automatically copied to when
+     * cross-region snapshot copy is enabled.</p>
+     */
+    inline void SetDestinationRegion(const Aws::String& value) { m_destinationRegionHasBeenSet = true; m_destinationRegion = value; }
+
+    /**
+     * <p>The destination region that snapshots are automatically copied to when
+     * cross-region snapshot copy is enabled.</p>
+     */
+    inline void SetDestinationRegion(Aws::String&& value) { m_destinationRegionHasBeenSet = true; m_destinationRegion = std::move(value); }
+
+    /**
+     * <p>The destination region that snapshots are automatically copied to when
+     * cross-region snapshot copy is enabled.</p>
+     */
+    inline void SetDestinationRegion(const char* value) { m_destinationRegionHasBeenSet = true; m_destinationRegion.assign(value); }
+
+    /**
+     * <p>The destination region that snapshots are automatically copied to when
+     * cross-region snapshot copy is enabled.</p>
+     */
+    inline ClusterSnapshotCopyStatus& WithDestinationRegion(const Aws::String& value) { SetDestinationRegion(value); return *this;}
+
+    /**
+     * <p>The destination region that snapshots are automatically copied to when
+     * cross-region snapshot copy is enabled.</p>
+     */
+    inline ClusterSnapshotCopyStatus& WithDestinationRegion(Aws::String&& value) { SetDestinationRegion(std::move(value)); return *this;}
+
+    /**
+     * <p>The destination region that snapshots are automatically copied to when
+     * cross-region snapshot copy is enabled.</p>
+     */
+    inline ClusterSnapshotCopyStatus& WithDestinationRegion(const char* value) { SetDestinationRegion(value); return *this;}
+
+
+    /**
+     * <p>The number of days that automated snapshots are retained in the destination
+     * region after they are copied from a source region.</p>
+     */
+    inline long long GetRetentionPeriod() const{ return m_retentionPeriod; }
+
+    /**
+     * <p>The number of days that automated snapshots are retained in the destination
+     * region after they are copied from a source region.</p>
+     */
+    inline bool RetentionPeriodHasBeenSet() const { return m_retentionPeriodHasBeenSet; }
+
+    /**
+     * <p>The number of days that automated snapshots are retained in the destination
+     * region after they are copied from a source region.</p>
+     */
+    inline void SetRetentionPeriod(long long value) { m_retentionPeriodHasBeenSet = true; m_retentionPeriod = value; }
+
+    /**
+     * <p>The number of days that automated snapshots are retained in the destination
+     * region after they are copied from a source region.</p>
+     */
+    inline ClusterSnapshotCopyStatus& WithRetentionPeriod(long long value) { SetRetentionPeriod(value); return *this;}
+
+
+    /**
+     * <p>The number of days that automated snapshots are retained in the destination
+     * region after they are copied from a source region. If the value is -1, the
+     * manual snapshot is retained indefinitely. </p> <p>The value must be either -1 or
+     * an integer between 1 and 3,653.</p>
+     */
+    inline int GetManualSnapshotRetentionPeriod() const{ return m_manualSnapshotRetentionPeriod; }
+
+    /**
+     * <p>The number of days that automated snapshots are retained in the destination
+     * region after they are copied from a source region. If the value is -1, the
+     * manual snapshot is retained indefinitely. </p> <p>The value must be either -1 or
+     * an integer between 1 and 3,653.</p>
+     */
+    inline bool ManualSnapshotRetentionPeriodHasBeenSet() const { return m_manualSnapshotRetentionPeriodHasBeenSet; }
+
+    /**
+     * <p>The number of days that automated snapshots are retained in the destination
+     * region after they are copied from a source region. If the value is -1, the
+     * manual snapshot is retained indefinitely. </p> <p>The value must be either -1 or
+     * an integer between 1 and 3,653.</p>
+     */
+    inline void SetManualSnapshotRetentionPeriod(int value) { m_manualSnapshotRetentionPeriodHasBeenSet = true; m_manualSnapshotRetentionPeriod = value; }
+
+    /**
+     * <p>The number of days that automated snapshots are retained in the destination
+     * region after they are copied from a source region. If the value is -1, the
+     * manual snapshot is retained indefinitely. </p> <p>The value must be either -1 or
+     * an integer between 1 and 3,653.</p>
+     */
+    inline ClusterSnapshotCopyStatus& WithManualSnapshotRetentionPeriod(int value) { SetManualSnapshotRetentionPeriod(value); return *this;}
+
+
+    /**
+     * <p>The name of the snapshot copy grant.</p>
+     */
+    inline const Aws::String& GetSnapshotCopyGrantName() const{ return m_snapshotCopyGrantName; }
+
+    /**
+     * <p>The name of the snapshot copy grant.</p>
+     */
+    inline bool SnapshotCopyGrantNameHasBeenSet() const { return m_snapshotCopyGrantNameHasBeenSet; }
+
+    /**
+     * <p>The name of the snapshot copy grant.</p>
+     */
+    inline void SetSnapshotCopyGrantName(const Aws::String& value) { m_snapshotCopyGrantNameHasBeenSet = true; m_snapshotCopyGrantName = value; }
+
+    /**
+     * <p>The name of the snapshot copy grant.</p>
+     */
+    inline void SetSnapshotCopyGrantName(Aws::String&& value) { m_snapshotCopyGrantNameHasBeenSet = true; m_snapshotCopyGrantName = std::move(value); }
+
+    /**
+     * <p>The name of the snapshot copy grant.</p>
+     */
+    inline void SetSnapshotCopyGrantName(const char* value) { m_snapshotCopyGrantNameHasBeenSet = true; m_snapshotCopyGrantName.assign(value); }
+
+    /**
+     * <p>The name of the snapshot copy grant.</p>
+     */
+    inline ClusterSnapshotCopyStatus& WithSnapshotCopyGrantName(const Aws::String& value) { SetSnapshotCopyGrantName(value); return *this;}
+
+    /**
+     * <p>The name of the snapshot copy grant.</p>
+     */
+    inline ClusterSnapshotCopyStatus& WithSnapshotCopyGrantName(Aws::String&& value) { SetSnapshotCopyGrantName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the snapshot copy grant.</p>
+     */
+    inline ClusterSnapshotCopyStatus& WithSnapshotCopyGrantName(const char* value) { SetSnapshotCopyGrantName(value); return *this;}
+
+  private:
+
+    Aws::String m_destinationRegion;
+    bool m_destinationRegionHasBeenSet;
+
+    long long m_retentionPeriod;
+    bool m_retentionPeriodHasBeenSet;
+
+    int m_manualSnapshotRetentionPeriod;
+    bool m_manualSnapshotRetentionPeriodHasBeenSet;
+
+    Aws::String m_snapshotCopyGrantName;
+    bool m_snapshotCopyGrantNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/ClusterSubnetGroup.h

@@ -0,0 +1,321 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/Subnet.h>
+#include <aws/redshift/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p>Describes a subnet group.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/ClusterSubnetGroup">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API ClusterSubnetGroup
+  {
+  public:
+    ClusterSubnetGroup();
+    ClusterSubnetGroup(const Aws::Utils::Xml::XmlNode& xmlNode);
+    ClusterSubnetGroup& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    /**
+     * <p>The name of the cluster subnet group.</p>
+     */
+    inline const Aws::String& GetClusterSubnetGroupName() const{ return m_clusterSubnetGroupName; }
+
+    /**
+     * <p>The name of the cluster subnet group.</p>
+     */
+    inline bool ClusterSubnetGroupNameHasBeenSet() const { return m_clusterSubnetGroupNameHasBeenSet; }
+
+    /**
+     * <p>The name of the cluster subnet group.</p>
+     */
+    inline void SetClusterSubnetGroupName(const Aws::String& value) { m_clusterSubnetGroupNameHasBeenSet = true; m_clusterSubnetGroupName = value; }
+
+    /**
+     * <p>The name of the cluster subnet group.</p>
+     */
+    inline void SetClusterSubnetGroupName(Aws::String&& value) { m_clusterSubnetGroupNameHasBeenSet = true; m_clusterSubnetGroupName = std::move(value); }
+
+    /**
+     * <p>The name of the cluster subnet group.</p>
+     */
+    inline void SetClusterSubnetGroupName(const char* value) { m_clusterSubnetGroupNameHasBeenSet = true; m_clusterSubnetGroupName.assign(value); }
+
+    /**
+     * <p>The name of the cluster subnet group.</p>
+     */
+    inline ClusterSubnetGroup& WithClusterSubnetGroupName(const Aws::String& value) { SetClusterSubnetGroupName(value); return *this;}
+
+    /**
+     * <p>The name of the cluster subnet group.</p>
+     */
+    inline ClusterSubnetGroup& WithClusterSubnetGroupName(Aws::String&& value) { SetClusterSubnetGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the cluster subnet group.</p>
+     */
+    inline ClusterSubnetGroup& WithClusterSubnetGroupName(const char* value) { SetClusterSubnetGroupName(value); return *this;}
+
+
+    /**
+     * <p>The description of the cluster subnet group.</p>
+     */
+    inline const Aws::String& GetDescription() const{ return m_description; }
+
+    /**
+     * <p>The description of the cluster subnet group.</p>
+     */
+    inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
+
+    /**
+     * <p>The description of the cluster subnet group.</p>
+     */
+    inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
+
+    /**
+     * <p>The description of the cluster subnet group.</p>
+     */
+    inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
+
+    /**
+     * <p>The description of the cluster subnet group.</p>
+     */
+    inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
+
+    /**
+     * <p>The description of the cluster subnet group.</p>
+     */
+    inline ClusterSubnetGroup& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
+
+    /**
+     * <p>The description of the cluster subnet group.</p>
+     */
+    inline ClusterSubnetGroup& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
+
+    /**
+     * <p>The description of the cluster subnet group.</p>
+     */
+    inline ClusterSubnetGroup& WithDescription(const char* value) { SetDescription(value); return *this;}
+
+
+    /**
+     * <p>The VPC ID of the cluster subnet group.</p>
+     */
+    inline const Aws::String& GetVpcId() const{ return m_vpcId; }
+
+    /**
+     * <p>The VPC ID of the cluster subnet group.</p>
+     */
+    inline bool VpcIdHasBeenSet() const { return m_vpcIdHasBeenSet; }
+
+    /**
+     * <p>The VPC ID of the cluster subnet group.</p>
+     */
+    inline void SetVpcId(const Aws::String& value) { m_vpcIdHasBeenSet = true; m_vpcId = value; }
+
+    /**
+     * <p>The VPC ID of the cluster subnet group.</p>
+     */
+    inline void SetVpcId(Aws::String&& value) { m_vpcIdHasBeenSet = true; m_vpcId = std::move(value); }
+
+    /**
+     * <p>The VPC ID of the cluster subnet group.</p>
+     */
+    inline void SetVpcId(const char* value) { m_vpcIdHasBeenSet = true; m_vpcId.assign(value); }
+
+    /**
+     * <p>The VPC ID of the cluster subnet group.</p>
+     */
+    inline ClusterSubnetGroup& WithVpcId(const Aws::String& value) { SetVpcId(value); return *this;}
+
+    /**
+     * <p>The VPC ID of the cluster subnet group.</p>
+     */
+    inline ClusterSubnetGroup& WithVpcId(Aws::String&& value) { SetVpcId(std::move(value)); return *this;}
+
+    /**
+     * <p>The VPC ID of the cluster subnet group.</p>
+     */
+    inline ClusterSubnetGroup& WithVpcId(const char* value) { SetVpcId(value); return *this;}
+
+
+    /**
+     * <p>The status of the cluster subnet group. Possible values are
+     * <code>Complete</code>, <code>Incomplete</code> and <code>Invalid</code>. </p>
+     */
+    inline const Aws::String& GetSubnetGroupStatus() const{ return m_subnetGroupStatus; }
+
+    /**
+     * <p>The status of the cluster subnet group. Possible values are
+     * <code>Complete</code>, <code>Incomplete</code> and <code>Invalid</code>. </p>
+     */
+    inline bool SubnetGroupStatusHasBeenSet() const { return m_subnetGroupStatusHasBeenSet; }
+
+    /**
+     * <p>The status of the cluster subnet group. Possible values are
+     * <code>Complete</code>, <code>Incomplete</code> and <code>Invalid</code>. </p>
+     */
+    inline void SetSubnetGroupStatus(const Aws::String& value) { m_subnetGroupStatusHasBeenSet = true; m_subnetGroupStatus = value; }
+
+    /**
+     * <p>The status of the cluster subnet group. Possible values are
+     * <code>Complete</code>, <code>Incomplete</code> and <code>Invalid</code>. </p>
+     */
+    inline void SetSubnetGroupStatus(Aws::String&& value) { m_subnetGroupStatusHasBeenSet = true; m_subnetGroupStatus = std::move(value); }
+
+    /**
+     * <p>The status of the cluster subnet group. Possible values are
+     * <code>Complete</code>, <code>Incomplete</code> and <code>Invalid</code>. </p>
+     */
+    inline void SetSubnetGroupStatus(const char* value) { m_subnetGroupStatusHasBeenSet = true; m_subnetGroupStatus.assign(value); }
+
+    /**
+     * <p>The status of the cluster subnet group. Possible values are
+     * <code>Complete</code>, <code>Incomplete</code> and <code>Invalid</code>. </p>
+     */
+    inline ClusterSubnetGroup& WithSubnetGroupStatus(const Aws::String& value) { SetSubnetGroupStatus(value); return *this;}
+
+    /**
+     * <p>The status of the cluster subnet group. Possible values are
+     * <code>Complete</code>, <code>Incomplete</code> and <code>Invalid</code>. </p>
+     */
+    inline ClusterSubnetGroup& WithSubnetGroupStatus(Aws::String&& value) { SetSubnetGroupStatus(std::move(value)); return *this;}
+
+    /**
+     * <p>The status of the cluster subnet group. Possible values are
+     * <code>Complete</code>, <code>Incomplete</code> and <code>Invalid</code>. </p>
+     */
+    inline ClusterSubnetGroup& WithSubnetGroupStatus(const char* value) { SetSubnetGroupStatus(value); return *this;}
+
+
+    /**
+     * <p>A list of the VPC <a>Subnet</a> elements. </p>
+     */
+    inline const Aws::Vector<Subnet>& GetSubnets() const{ return m_subnets; }
+
+    /**
+     * <p>A list of the VPC <a>Subnet</a> elements. </p>
+     */
+    inline bool SubnetsHasBeenSet() const { return m_subnetsHasBeenSet; }
+
+    /**
+     * <p>A list of the VPC <a>Subnet</a> elements. </p>
+     */
+    inline void SetSubnets(const Aws::Vector<Subnet>& value) { m_subnetsHasBeenSet = true; m_subnets = value; }
+
+    /**
+     * <p>A list of the VPC <a>Subnet</a> elements. </p>
+     */
+    inline void SetSubnets(Aws::Vector<Subnet>&& value) { m_subnetsHasBeenSet = true; m_subnets = std::move(value); }
+
+    /**
+     * <p>A list of the VPC <a>Subnet</a> elements. </p>
+     */
+    inline ClusterSubnetGroup& WithSubnets(const Aws::Vector<Subnet>& value) { SetSubnets(value); return *this;}
+
+    /**
+     * <p>A list of the VPC <a>Subnet</a> elements. </p>
+     */
+    inline ClusterSubnetGroup& WithSubnets(Aws::Vector<Subnet>&& value) { SetSubnets(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of the VPC <a>Subnet</a> elements. </p>
+     */
+    inline ClusterSubnetGroup& AddSubnets(const Subnet& value) { m_subnetsHasBeenSet = true; m_subnets.push_back(value); return *this; }
+
+    /**
+     * <p>A list of the VPC <a>Subnet</a> elements. </p>
+     */
+    inline ClusterSubnetGroup& AddSubnets(Subnet&& value) { m_subnetsHasBeenSet = true; m_subnets.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>The list of tags for the cluster subnet group.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>The list of tags for the cluster subnet group.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>The list of tags for the cluster subnet group.</p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>The list of tags for the cluster subnet group.</p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>The list of tags for the cluster subnet group.</p>
+     */
+    inline ClusterSubnetGroup& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>The list of tags for the cluster subnet group.</p>
+     */
+    inline ClusterSubnetGroup& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>The list of tags for the cluster subnet group.</p>
+     */
+    inline ClusterSubnetGroup& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>The list of tags for the cluster subnet group.</p>
+     */
+    inline ClusterSubnetGroup& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_clusterSubnetGroupName;
+    bool m_clusterSubnetGroupNameHasBeenSet;
+
+    Aws::String m_description;
+    bool m_descriptionHasBeenSet;
+
+    Aws::String m_vpcId;
+    bool m_vpcIdHasBeenSet;
+
+    Aws::String m_subnetGroupStatus;
+    bool m_subnetGroupStatusHasBeenSet;
+
+    Aws::Vector<Subnet> m_subnets;
+    bool m_subnetsHasBeenSet;
+
+    Aws::Vector<Tag> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/ClusterVersion.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/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p>Describes a cluster version, including the parameter group family and
+   * description of the version.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/ClusterVersion">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API ClusterVersion
+  {
+  public:
+    ClusterVersion();
+    ClusterVersion(const Aws::Utils::Xml::XmlNode& xmlNode);
+    ClusterVersion& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    /**
+     * <p>The version number used by the cluster.</p>
+     */
+    inline const Aws::String& GetClusterVersion() const{ return m_clusterVersion; }
+
+    /**
+     * <p>The version number used by the cluster.</p>
+     */
+    inline bool ClusterVersionHasBeenSet() const { return m_clusterVersionHasBeenSet; }
+
+    /**
+     * <p>The version number used by the cluster.</p>
+     */
+    inline void SetClusterVersion(const Aws::String& value) { m_clusterVersionHasBeenSet = true; m_clusterVersion = value; }
+
+    /**
+     * <p>The version number used by the cluster.</p>
+     */
+    inline void SetClusterVersion(Aws::String&& value) { m_clusterVersionHasBeenSet = true; m_clusterVersion = std::move(value); }
+
+    /**
+     * <p>The version number used by the cluster.</p>
+     */
+    inline void SetClusterVersion(const char* value) { m_clusterVersionHasBeenSet = true; m_clusterVersion.assign(value); }
+
+    /**
+     * <p>The version number used by the cluster.</p>
+     */
+    inline ClusterVersion& WithClusterVersion(const Aws::String& value) { SetClusterVersion(value); return *this;}
+
+    /**
+     * <p>The version number used by the cluster.</p>
+     */
+    inline ClusterVersion& WithClusterVersion(Aws::String&& value) { SetClusterVersion(std::move(value)); return *this;}
+
+    /**
+     * <p>The version number used by the cluster.</p>
+     */
+    inline ClusterVersion& WithClusterVersion(const char* value) { SetClusterVersion(value); return *this;}
+
+
+    /**
+     * <p>The name of the cluster parameter group family for the cluster.</p>
+     */
+    inline const Aws::String& GetClusterParameterGroupFamily() const{ return m_clusterParameterGroupFamily; }
+
+    /**
+     * <p>The name of the cluster parameter group family for the cluster.</p>
+     */
+    inline bool ClusterParameterGroupFamilyHasBeenSet() const { return m_clusterParameterGroupFamilyHasBeenSet; }
+
+    /**
+     * <p>The name of the cluster parameter group family for the cluster.</p>
+     */
+    inline void SetClusterParameterGroupFamily(const Aws::String& value) { m_clusterParameterGroupFamilyHasBeenSet = true; m_clusterParameterGroupFamily = value; }
+
+    /**
+     * <p>The name of the cluster parameter group family for the cluster.</p>
+     */
+    inline void SetClusterParameterGroupFamily(Aws::String&& value) { m_clusterParameterGroupFamilyHasBeenSet = true; m_clusterParameterGroupFamily = std::move(value); }
+
+    /**
+     * <p>The name of the cluster parameter group family for the cluster.</p>
+     */
+    inline void SetClusterParameterGroupFamily(const char* value) { m_clusterParameterGroupFamilyHasBeenSet = true; m_clusterParameterGroupFamily.assign(value); }
+
+    /**
+     * <p>The name of the cluster parameter group family for the cluster.</p>
+     */
+    inline ClusterVersion& WithClusterParameterGroupFamily(const Aws::String& value) { SetClusterParameterGroupFamily(value); return *this;}
+
+    /**
+     * <p>The name of the cluster parameter group family for the cluster.</p>
+     */
+    inline ClusterVersion& WithClusterParameterGroupFamily(Aws::String&& value) { SetClusterParameterGroupFamily(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the cluster parameter group family for the cluster.</p>
+     */
+    inline ClusterVersion& WithClusterParameterGroupFamily(const char* value) { SetClusterParameterGroupFamily(value); return *this;}
+
+
+    /**
+     * <p>The description of the cluster version.</p>
+     */
+    inline const Aws::String& GetDescription() const{ return m_description; }
+
+    /**
+     * <p>The description of the cluster version.</p>
+     */
+    inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
+
+    /**
+     * <p>The description of the cluster version.</p>
+     */
+    inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
+
+    /**
+     * <p>The description of the cluster version.</p>
+     */
+    inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
+
+    /**
+     * <p>The description of the cluster version.</p>
+     */
+    inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
+
+    /**
+     * <p>The description of the cluster version.</p>
+     */
+    inline ClusterVersion& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
+
+    /**
+     * <p>The description of the cluster version.</p>
+     */
+    inline ClusterVersion& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
+
+    /**
+     * <p>The description of the cluster version.</p>
+     */
+    inline ClusterVersion& WithDescription(const char* value) { SetDescription(value); return *this;}
+
+  private:
+
+    Aws::String m_clusterVersion;
+    bool m_clusterVersionHasBeenSet;
+
+    Aws::String m_clusterParameterGroupFamily;
+    bool m_clusterParameterGroupFamilyHasBeenSet;
+
+    Aws::String m_description;
+    bool m_descriptionHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/CopyClusterSnapshotRequest.h

@@ -0,0 +1,298 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p/><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/CopyClusterSnapshotMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API CopyClusterSnapshotRequest : public RedshiftRequest
+  {
+  public:
+    CopyClusterSnapshotRequest();
+
+    // 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 "CopyClusterSnapshot"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The identifier for the source snapshot.</p> <p>Constraints:</p> <ul> <li>
+     * <p>Must be the identifier for a valid automated snapshot whose state is
+     * <code>available</code>.</p> </li> </ul>
+     */
+    inline const Aws::String& GetSourceSnapshotIdentifier() const{ return m_sourceSnapshotIdentifier; }
+
+    /**
+     * <p>The identifier for the source snapshot.</p> <p>Constraints:</p> <ul> <li>
+     * <p>Must be the identifier for a valid automated snapshot whose state is
+     * <code>available</code>.</p> </li> </ul>
+     */
+    inline bool SourceSnapshotIdentifierHasBeenSet() const { return m_sourceSnapshotIdentifierHasBeenSet; }
+
+    /**
+     * <p>The identifier for the source snapshot.</p> <p>Constraints:</p> <ul> <li>
+     * <p>Must be the identifier for a valid automated snapshot whose state is
+     * <code>available</code>.</p> </li> </ul>
+     */
+    inline void SetSourceSnapshotIdentifier(const Aws::String& value) { m_sourceSnapshotIdentifierHasBeenSet = true; m_sourceSnapshotIdentifier = value; }
+
+    /**
+     * <p>The identifier for the source snapshot.</p> <p>Constraints:</p> <ul> <li>
+     * <p>Must be the identifier for a valid automated snapshot whose state is
+     * <code>available</code>.</p> </li> </ul>
+     */
+    inline void SetSourceSnapshotIdentifier(Aws::String&& value) { m_sourceSnapshotIdentifierHasBeenSet = true; m_sourceSnapshotIdentifier = std::move(value); }
+
+    /**
+     * <p>The identifier for the source snapshot.</p> <p>Constraints:</p> <ul> <li>
+     * <p>Must be the identifier for a valid automated snapshot whose state is
+     * <code>available</code>.</p> </li> </ul>
+     */
+    inline void SetSourceSnapshotIdentifier(const char* value) { m_sourceSnapshotIdentifierHasBeenSet = true; m_sourceSnapshotIdentifier.assign(value); }
+
+    /**
+     * <p>The identifier for the source snapshot.</p> <p>Constraints:</p> <ul> <li>
+     * <p>Must be the identifier for a valid automated snapshot whose state is
+     * <code>available</code>.</p> </li> </ul>
+     */
+    inline CopyClusterSnapshotRequest& WithSourceSnapshotIdentifier(const Aws::String& value) { SetSourceSnapshotIdentifier(value); return *this;}
+
+    /**
+     * <p>The identifier for the source snapshot.</p> <p>Constraints:</p> <ul> <li>
+     * <p>Must be the identifier for a valid automated snapshot whose state is
+     * <code>available</code>.</p> </li> </ul>
+     */
+    inline CopyClusterSnapshotRequest& WithSourceSnapshotIdentifier(Aws::String&& value) { SetSourceSnapshotIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>The identifier for the source snapshot.</p> <p>Constraints:</p> <ul> <li>
+     * <p>Must be the identifier for a valid automated snapshot whose state is
+     * <code>available</code>.</p> </li> </ul>
+     */
+    inline CopyClusterSnapshotRequest& WithSourceSnapshotIdentifier(const char* value) { SetSourceSnapshotIdentifier(value); return *this;}
+
+
+    /**
+     * <p>The identifier of the cluster the source snapshot was created from. This
+     * parameter is required if your IAM user has a policy containing a snapshot
+     * resource element that specifies anything other than * for the cluster name.</p>
+     * <p>Constraints:</p> <ul> <li> <p>Must be the identifier for a valid cluster.</p>
+     * </li> </ul>
+     */
+    inline const Aws::String& GetSourceSnapshotClusterIdentifier() const{ return m_sourceSnapshotClusterIdentifier; }
+
+    /**
+     * <p>The identifier of the cluster the source snapshot was created from. This
+     * parameter is required if your IAM user has a policy containing a snapshot
+     * resource element that specifies anything other than * for the cluster name.</p>
+     * <p>Constraints:</p> <ul> <li> <p>Must be the identifier for a valid cluster.</p>
+     * </li> </ul>
+     */
+    inline bool SourceSnapshotClusterIdentifierHasBeenSet() const { return m_sourceSnapshotClusterIdentifierHasBeenSet; }
+
+    /**
+     * <p>The identifier of the cluster the source snapshot was created from. This
+     * parameter is required if your IAM user has a policy containing a snapshot
+     * resource element that specifies anything other than * for the cluster name.</p>
+     * <p>Constraints:</p> <ul> <li> <p>Must be the identifier for a valid cluster.</p>
+     * </li> </ul>
+     */
+    inline void SetSourceSnapshotClusterIdentifier(const Aws::String& value) { m_sourceSnapshotClusterIdentifierHasBeenSet = true; m_sourceSnapshotClusterIdentifier = value; }
+
+    /**
+     * <p>The identifier of the cluster the source snapshot was created from. This
+     * parameter is required if your IAM user has a policy containing a snapshot
+     * resource element that specifies anything other than * for the cluster name.</p>
+     * <p>Constraints:</p> <ul> <li> <p>Must be the identifier for a valid cluster.</p>
+     * </li> </ul>
+     */
+    inline void SetSourceSnapshotClusterIdentifier(Aws::String&& value) { m_sourceSnapshotClusterIdentifierHasBeenSet = true; m_sourceSnapshotClusterIdentifier = std::move(value); }
+
+    /**
+     * <p>The identifier of the cluster the source snapshot was created from. This
+     * parameter is required if your IAM user has a policy containing a snapshot
+     * resource element that specifies anything other than * for the cluster name.</p>
+     * <p>Constraints:</p> <ul> <li> <p>Must be the identifier for a valid cluster.</p>
+     * </li> </ul>
+     */
+    inline void SetSourceSnapshotClusterIdentifier(const char* value) { m_sourceSnapshotClusterIdentifierHasBeenSet = true; m_sourceSnapshotClusterIdentifier.assign(value); }
+
+    /**
+     * <p>The identifier of the cluster the source snapshot was created from. This
+     * parameter is required if your IAM user has a policy containing a snapshot
+     * resource element that specifies anything other than * for the cluster name.</p>
+     * <p>Constraints:</p> <ul> <li> <p>Must be the identifier for a valid cluster.</p>
+     * </li> </ul>
+     */
+    inline CopyClusterSnapshotRequest& WithSourceSnapshotClusterIdentifier(const Aws::String& value) { SetSourceSnapshotClusterIdentifier(value); return *this;}
+
+    /**
+     * <p>The identifier of the cluster the source snapshot was created from. This
+     * parameter is required if your IAM user has a policy containing a snapshot
+     * resource element that specifies anything other than * for the cluster name.</p>
+     * <p>Constraints:</p> <ul> <li> <p>Must be the identifier for a valid cluster.</p>
+     * </li> </ul>
+     */
+    inline CopyClusterSnapshotRequest& WithSourceSnapshotClusterIdentifier(Aws::String&& value) { SetSourceSnapshotClusterIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>The identifier of the cluster the source snapshot was created from. This
+     * parameter is required if your IAM user has a policy containing a snapshot
+     * resource element that specifies anything other than * for the cluster name.</p>
+     * <p>Constraints:</p> <ul> <li> <p>Must be the identifier for a valid cluster.</p>
+     * </li> </ul>
+     */
+    inline CopyClusterSnapshotRequest& WithSourceSnapshotClusterIdentifier(const char* value) { SetSourceSnapshotClusterIdentifier(value); return *this;}
+
+
+    /**
+     * <p>The identifier given to the new manual snapshot.</p> <p>Constraints:</p> <ul>
+     * <li> <p>Cannot be null, empty, or blank.</p> </li> <li> <p>Must contain from 1
+     * to 255 alphanumeric characters or hyphens.</p> </li> <li> <p>First character
+     * must be a letter.</p> </li> <li> <p>Cannot end with a hyphen or contain two
+     * consecutive hyphens.</p> </li> <li> <p>Must be unique for the AWS account that
+     * is making the request.</p> </li> </ul>
+     */
+    inline const Aws::String& GetTargetSnapshotIdentifier() const{ return m_targetSnapshotIdentifier; }
+
+    /**
+     * <p>The identifier given to the new manual snapshot.</p> <p>Constraints:</p> <ul>
+     * <li> <p>Cannot be null, empty, or blank.</p> </li> <li> <p>Must contain from 1
+     * to 255 alphanumeric characters or hyphens.</p> </li> <li> <p>First character
+     * must be a letter.</p> </li> <li> <p>Cannot end with a hyphen or contain two
+     * consecutive hyphens.</p> </li> <li> <p>Must be unique for the AWS account that
+     * is making the request.</p> </li> </ul>
+     */
+    inline bool TargetSnapshotIdentifierHasBeenSet() const { return m_targetSnapshotIdentifierHasBeenSet; }
+
+    /**
+     * <p>The identifier given to the new manual snapshot.</p> <p>Constraints:</p> <ul>
+     * <li> <p>Cannot be null, empty, or blank.</p> </li> <li> <p>Must contain from 1
+     * to 255 alphanumeric characters or hyphens.</p> </li> <li> <p>First character
+     * must be a letter.</p> </li> <li> <p>Cannot end with a hyphen or contain two
+     * consecutive hyphens.</p> </li> <li> <p>Must be unique for the AWS account that
+     * is making the request.</p> </li> </ul>
+     */
+    inline void SetTargetSnapshotIdentifier(const Aws::String& value) { m_targetSnapshotIdentifierHasBeenSet = true; m_targetSnapshotIdentifier = value; }
+
+    /**
+     * <p>The identifier given to the new manual snapshot.</p> <p>Constraints:</p> <ul>
+     * <li> <p>Cannot be null, empty, or blank.</p> </li> <li> <p>Must contain from 1
+     * to 255 alphanumeric characters or hyphens.</p> </li> <li> <p>First character
+     * must be a letter.</p> </li> <li> <p>Cannot end with a hyphen or contain two
+     * consecutive hyphens.</p> </li> <li> <p>Must be unique for the AWS account that
+     * is making the request.</p> </li> </ul>
+     */
+    inline void SetTargetSnapshotIdentifier(Aws::String&& value) { m_targetSnapshotIdentifierHasBeenSet = true; m_targetSnapshotIdentifier = std::move(value); }
+
+    /**
+     * <p>The identifier given to the new manual snapshot.</p> <p>Constraints:</p> <ul>
+     * <li> <p>Cannot be null, empty, or blank.</p> </li> <li> <p>Must contain from 1
+     * to 255 alphanumeric characters or hyphens.</p> </li> <li> <p>First character
+     * must be a letter.</p> </li> <li> <p>Cannot end with a hyphen or contain two
+     * consecutive hyphens.</p> </li> <li> <p>Must be unique for the AWS account that
+     * is making the request.</p> </li> </ul>
+     */
+    inline void SetTargetSnapshotIdentifier(const char* value) { m_targetSnapshotIdentifierHasBeenSet = true; m_targetSnapshotIdentifier.assign(value); }
+
+    /**
+     * <p>The identifier given to the new manual snapshot.</p> <p>Constraints:</p> <ul>
+     * <li> <p>Cannot be null, empty, or blank.</p> </li> <li> <p>Must contain from 1
+     * to 255 alphanumeric characters or hyphens.</p> </li> <li> <p>First character
+     * must be a letter.</p> </li> <li> <p>Cannot end with a hyphen or contain two
+     * consecutive hyphens.</p> </li> <li> <p>Must be unique for the AWS account that
+     * is making the request.</p> </li> </ul>
+     */
+    inline CopyClusterSnapshotRequest& WithTargetSnapshotIdentifier(const Aws::String& value) { SetTargetSnapshotIdentifier(value); return *this;}
+
+    /**
+     * <p>The identifier given to the new manual snapshot.</p> <p>Constraints:</p> <ul>
+     * <li> <p>Cannot be null, empty, or blank.</p> </li> <li> <p>Must contain from 1
+     * to 255 alphanumeric characters or hyphens.</p> </li> <li> <p>First character
+     * must be a letter.</p> </li> <li> <p>Cannot end with a hyphen or contain two
+     * consecutive hyphens.</p> </li> <li> <p>Must be unique for the AWS account that
+     * is making the request.</p> </li> </ul>
+     */
+    inline CopyClusterSnapshotRequest& WithTargetSnapshotIdentifier(Aws::String&& value) { SetTargetSnapshotIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>The identifier given to the new manual snapshot.</p> <p>Constraints:</p> <ul>
+     * <li> <p>Cannot be null, empty, or blank.</p> </li> <li> <p>Must contain from 1
+     * to 255 alphanumeric characters or hyphens.</p> </li> <li> <p>First character
+     * must be a letter.</p> </li> <li> <p>Cannot end with a hyphen or contain two
+     * consecutive hyphens.</p> </li> <li> <p>Must be unique for the AWS account that
+     * is making the request.</p> </li> </ul>
+     */
+    inline CopyClusterSnapshotRequest& WithTargetSnapshotIdentifier(const char* value) { SetTargetSnapshotIdentifier(value); return *this;}
+
+
+    /**
+     * <p>The number of days that a manual snapshot is retained. If the value is -1,
+     * the manual snapshot is retained indefinitely. </p> <p>The value must be either
+     * -1 or an integer between 1 and 3,653.</p> <p>The default value is -1.</p>
+     */
+    inline int GetManualSnapshotRetentionPeriod() const{ return m_manualSnapshotRetentionPeriod; }
+
+    /**
+     * <p>The number of days that a manual snapshot is retained. If the value is -1,
+     * the manual snapshot is retained indefinitely. </p> <p>The value must be either
+     * -1 or an integer between 1 and 3,653.</p> <p>The default value is -1.</p>
+     */
+    inline bool ManualSnapshotRetentionPeriodHasBeenSet() const { return m_manualSnapshotRetentionPeriodHasBeenSet; }
+
+    /**
+     * <p>The number of days that a manual snapshot is retained. If the value is -1,
+     * the manual snapshot is retained indefinitely. </p> <p>The value must be either
+     * -1 or an integer between 1 and 3,653.</p> <p>The default value is -1.</p>
+     */
+    inline void SetManualSnapshotRetentionPeriod(int value) { m_manualSnapshotRetentionPeriodHasBeenSet = true; m_manualSnapshotRetentionPeriod = value; }
+
+    /**
+     * <p>The number of days that a manual snapshot is retained. If the value is -1,
+     * the manual snapshot is retained indefinitely. </p> <p>The value must be either
+     * -1 or an integer between 1 and 3,653.</p> <p>The default value is -1.</p>
+     */
+    inline CopyClusterSnapshotRequest& WithManualSnapshotRetentionPeriod(int value) { SetManualSnapshotRetentionPeriod(value); return *this;}
+
+  private:
+
+    Aws::String m_sourceSnapshotIdentifier;
+    bool m_sourceSnapshotIdentifierHasBeenSet;
+
+    Aws::String m_sourceSnapshotClusterIdentifier;
+    bool m_sourceSnapshotClusterIdentifierHasBeenSet;
+
+    Aws::String m_targetSnapshotIdentifier;
+    bool m_targetSnapshotIdentifierHasBeenSet;
+
+    int m_manualSnapshotRetentionPeriod;
+    bool m_manualSnapshotRetentionPeriodHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/CopyClusterSnapshotResult.h

@@ -0,0 +1,76 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/model/Snapshot.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  class AWS_REDSHIFT_API CopyClusterSnapshotResult
+  {
+  public:
+    CopyClusterSnapshotResult();
+    CopyClusterSnapshotResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    CopyClusterSnapshotResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    
+    inline const Snapshot& GetSnapshot() const{ return m_snapshot; }
+
+    
+    inline void SetSnapshot(const Snapshot& value) { m_snapshot = value; }
+
+    
+    inline void SetSnapshot(Snapshot&& value) { m_snapshot = std::move(value); }
+
+    
+    inline CopyClusterSnapshotResult& WithSnapshot(const Snapshot& value) { SetSnapshot(value); return *this;}
+
+    
+    inline CopyClusterSnapshotResult& WithSnapshot(Snapshot&& value) { SetSnapshot(std::move(value)); return *this;}
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline CopyClusterSnapshotResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline CopyClusterSnapshotResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    Snapshot m_snapshot;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/CreateClusterParameterGroupRequest.h

@@ -0,0 +1,328 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p/><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/CreateClusterParameterGroupMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API CreateClusterParameterGroupRequest : public RedshiftRequest
+  {
+  public:
+    CreateClusterParameterGroupRequest();
+
+    // 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 "CreateClusterParameterGroup"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The name of the cluster parameter group.</p> <p>Constraints:</p> <ul> <li>
+     * <p>Must be 1 to 255 alphanumeric characters or hyphens</p> </li> <li> <p>First
+     * character must be a letter.</p> </li> <li> <p>Cannot end with a hyphen or
+     * contain two consecutive hyphens.</p> </li> <li> <p>Must be unique withing your
+     * AWS account.</p> </li> </ul>  <p>This value is stored as a lower-case
+     * string.</p> 
+     */
+    inline const Aws::String& GetParameterGroupName() const{ return m_parameterGroupName; }
+
+    /**
+     * <p>The name of the cluster parameter group.</p> <p>Constraints:</p> <ul> <li>
+     * <p>Must be 1 to 255 alphanumeric characters or hyphens</p> </li> <li> <p>First
+     * character must be a letter.</p> </li> <li> <p>Cannot end with a hyphen or
+     * contain two consecutive hyphens.</p> </li> <li> <p>Must be unique withing your
+     * AWS account.</p> </li> </ul>  <p>This value is stored as a lower-case
+     * string.</p> 
+     */
+    inline bool ParameterGroupNameHasBeenSet() const { return m_parameterGroupNameHasBeenSet; }
+
+    /**
+     * <p>The name of the cluster parameter group.</p> <p>Constraints:</p> <ul> <li>
+     * <p>Must be 1 to 255 alphanumeric characters or hyphens</p> </li> <li> <p>First
+     * character must be a letter.</p> </li> <li> <p>Cannot end with a hyphen or
+     * contain two consecutive hyphens.</p> </li> <li> <p>Must be unique withing your
+     * AWS account.</p> </li> </ul>  <p>This value is stored as a lower-case
+     * string.</p> 
+     */
+    inline void SetParameterGroupName(const Aws::String& value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName = value; }
+
+    /**
+     * <p>The name of the cluster parameter group.</p> <p>Constraints:</p> <ul> <li>
+     * <p>Must be 1 to 255 alphanumeric characters or hyphens</p> </li> <li> <p>First
+     * character must be a letter.</p> </li> <li> <p>Cannot end with a hyphen or
+     * contain two consecutive hyphens.</p> </li> <li> <p>Must be unique withing your
+     * AWS account.</p> </li> </ul>  <p>This value is stored as a lower-case
+     * string.</p> 
+     */
+    inline void SetParameterGroupName(Aws::String&& value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName = std::move(value); }
+
+    /**
+     * <p>The name of the cluster parameter group.</p> <p>Constraints:</p> <ul> <li>
+     * <p>Must be 1 to 255 alphanumeric characters or hyphens</p> </li> <li> <p>First
+     * character must be a letter.</p> </li> <li> <p>Cannot end with a hyphen or
+     * contain two consecutive hyphens.</p> </li> <li> <p>Must be unique withing your
+     * AWS account.</p> </li> </ul>  <p>This value is stored as a lower-case
+     * string.</p> 
+     */
+    inline void SetParameterGroupName(const char* value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName.assign(value); }
+
+    /**
+     * <p>The name of the cluster parameter group.</p> <p>Constraints:</p> <ul> <li>
+     * <p>Must be 1 to 255 alphanumeric characters or hyphens</p> </li> <li> <p>First
+     * character must be a letter.</p> </li> <li> <p>Cannot end with a hyphen or
+     * contain two consecutive hyphens.</p> </li> <li> <p>Must be unique withing your
+     * AWS account.</p> </li> </ul>  <p>This value is stored as a lower-case
+     * string.</p> 
+     */
+    inline CreateClusterParameterGroupRequest& WithParameterGroupName(const Aws::String& value) { SetParameterGroupName(value); return *this;}
+
+    /**
+     * <p>The name of the cluster parameter group.</p> <p>Constraints:</p> <ul> <li>
+     * <p>Must be 1 to 255 alphanumeric characters or hyphens</p> </li> <li> <p>First
+     * character must be a letter.</p> </li> <li> <p>Cannot end with a hyphen or
+     * contain two consecutive hyphens.</p> </li> <li> <p>Must be unique withing your
+     * AWS account.</p> </li> </ul>  <p>This value is stored as a lower-case
+     * string.</p> 
+     */
+    inline CreateClusterParameterGroupRequest& WithParameterGroupName(Aws::String&& value) { SetParameterGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the cluster parameter group.</p> <p>Constraints:</p> <ul> <li>
+     * <p>Must be 1 to 255 alphanumeric characters or hyphens</p> </li> <li> <p>First
+     * character must be a letter.</p> </li> <li> <p>Cannot end with a hyphen or
+     * contain two consecutive hyphens.</p> </li> <li> <p>Must be unique withing your
+     * AWS account.</p> </li> </ul>  <p>This value is stored as a lower-case
+     * string.</p> 
+     */
+    inline CreateClusterParameterGroupRequest& WithParameterGroupName(const char* value) { SetParameterGroupName(value); return *this;}
+
+
+    /**
+     * <p>The Amazon Redshift engine version to which the cluster parameter group
+     * applies. The cluster engine version determines the set of parameters.</p> <p>To
+     * get a list of valid parameter group family names, you can call
+     * <a>DescribeClusterParameterGroups</a>. By default, Amazon Redshift returns a
+     * list of all the parameter groups that are owned by your AWS account, including
+     * the default parameter groups for each Amazon Redshift engine version. The
+     * parameter group family names associated with the default parameter groups
+     * provide you the valid values. For example, a valid family name is
+     * "redshift-1.0". </p>
+     */
+    inline const Aws::String& GetParameterGroupFamily() const{ return m_parameterGroupFamily; }
+
+    /**
+     * <p>The Amazon Redshift engine version to which the cluster parameter group
+     * applies. The cluster engine version determines the set of parameters.</p> <p>To
+     * get a list of valid parameter group family names, you can call
+     * <a>DescribeClusterParameterGroups</a>. By default, Amazon Redshift returns a
+     * list of all the parameter groups that are owned by your AWS account, including
+     * the default parameter groups for each Amazon Redshift engine version. The
+     * parameter group family names associated with the default parameter groups
+     * provide you the valid values. For example, a valid family name is
+     * "redshift-1.0". </p>
+     */
+    inline bool ParameterGroupFamilyHasBeenSet() const { return m_parameterGroupFamilyHasBeenSet; }
+
+    /**
+     * <p>The Amazon Redshift engine version to which the cluster parameter group
+     * applies. The cluster engine version determines the set of parameters.</p> <p>To
+     * get a list of valid parameter group family names, you can call
+     * <a>DescribeClusterParameterGroups</a>. By default, Amazon Redshift returns a
+     * list of all the parameter groups that are owned by your AWS account, including
+     * the default parameter groups for each Amazon Redshift engine version. The
+     * parameter group family names associated with the default parameter groups
+     * provide you the valid values. For example, a valid family name is
+     * "redshift-1.0". </p>
+     */
+    inline void SetParameterGroupFamily(const Aws::String& value) { m_parameterGroupFamilyHasBeenSet = true; m_parameterGroupFamily = value; }
+
+    /**
+     * <p>The Amazon Redshift engine version to which the cluster parameter group
+     * applies. The cluster engine version determines the set of parameters.</p> <p>To
+     * get a list of valid parameter group family names, you can call
+     * <a>DescribeClusterParameterGroups</a>. By default, Amazon Redshift returns a
+     * list of all the parameter groups that are owned by your AWS account, including
+     * the default parameter groups for each Amazon Redshift engine version. The
+     * parameter group family names associated with the default parameter groups
+     * provide you the valid values. For example, a valid family name is
+     * "redshift-1.0". </p>
+     */
+    inline void SetParameterGroupFamily(Aws::String&& value) { m_parameterGroupFamilyHasBeenSet = true; m_parameterGroupFamily = std::move(value); }
+
+    /**
+     * <p>The Amazon Redshift engine version to which the cluster parameter group
+     * applies. The cluster engine version determines the set of parameters.</p> <p>To
+     * get a list of valid parameter group family names, you can call
+     * <a>DescribeClusterParameterGroups</a>. By default, Amazon Redshift returns a
+     * list of all the parameter groups that are owned by your AWS account, including
+     * the default parameter groups for each Amazon Redshift engine version. The
+     * parameter group family names associated with the default parameter groups
+     * provide you the valid values. For example, a valid family name is
+     * "redshift-1.0". </p>
+     */
+    inline void SetParameterGroupFamily(const char* value) { m_parameterGroupFamilyHasBeenSet = true; m_parameterGroupFamily.assign(value); }
+
+    /**
+     * <p>The Amazon Redshift engine version to which the cluster parameter group
+     * applies. The cluster engine version determines the set of parameters.</p> <p>To
+     * get a list of valid parameter group family names, you can call
+     * <a>DescribeClusterParameterGroups</a>. By default, Amazon Redshift returns a
+     * list of all the parameter groups that are owned by your AWS account, including
+     * the default parameter groups for each Amazon Redshift engine version. The
+     * parameter group family names associated with the default parameter groups
+     * provide you the valid values. For example, a valid family name is
+     * "redshift-1.0". </p>
+     */
+    inline CreateClusterParameterGroupRequest& WithParameterGroupFamily(const Aws::String& value) { SetParameterGroupFamily(value); return *this;}
+
+    /**
+     * <p>The Amazon Redshift engine version to which the cluster parameter group
+     * applies. The cluster engine version determines the set of parameters.</p> <p>To
+     * get a list of valid parameter group family names, you can call
+     * <a>DescribeClusterParameterGroups</a>. By default, Amazon Redshift returns a
+     * list of all the parameter groups that are owned by your AWS account, including
+     * the default parameter groups for each Amazon Redshift engine version. The
+     * parameter group family names associated with the default parameter groups
+     * provide you the valid values. For example, a valid family name is
+     * "redshift-1.0". </p>
+     */
+    inline CreateClusterParameterGroupRequest& WithParameterGroupFamily(Aws::String&& value) { SetParameterGroupFamily(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Redshift engine version to which the cluster parameter group
+     * applies. The cluster engine version determines the set of parameters.</p> <p>To
+     * get a list of valid parameter group family names, you can call
+     * <a>DescribeClusterParameterGroups</a>. By default, Amazon Redshift returns a
+     * list of all the parameter groups that are owned by your AWS account, including
+     * the default parameter groups for each Amazon Redshift engine version. The
+     * parameter group family names associated with the default parameter groups
+     * provide you the valid values. For example, a valid family name is
+     * "redshift-1.0". </p>
+     */
+    inline CreateClusterParameterGroupRequest& WithParameterGroupFamily(const char* value) { SetParameterGroupFamily(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 CreateClusterParameterGroupRequest& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
+
+    /**
+     * <p>A description of the parameter group.</p>
+     */
+    inline CreateClusterParameterGroupRequest& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
+
+    /**
+     * <p>A description of the parameter group.</p>
+     */
+    inline CreateClusterParameterGroupRequest& WithDescription(const char* value) { SetDescription(value); return *this;}
+
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateClusterParameterGroupRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateClusterParameterGroupRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateClusterParameterGroupRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateClusterParameterGroupRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_parameterGroupName;
+    bool m_parameterGroupNameHasBeenSet;
+
+    Aws::String m_parameterGroupFamily;
+    bool m_parameterGroupFamilyHasBeenSet;
+
+    Aws::String m_description;
+    bool m_descriptionHasBeenSet;
+
+    Aws::Vector<Tag> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/CreateClusterParameterGroupResult.h

@@ -0,0 +1,76 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/model/ClusterParameterGroup.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  class AWS_REDSHIFT_API CreateClusterParameterGroupResult
+  {
+  public:
+    CreateClusterParameterGroupResult();
+    CreateClusterParameterGroupResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    CreateClusterParameterGroupResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    
+    inline const ClusterParameterGroup& GetClusterParameterGroup() const{ return m_clusterParameterGroup; }
+
+    
+    inline void SetClusterParameterGroup(const ClusterParameterGroup& value) { m_clusterParameterGroup = value; }
+
+    
+    inline void SetClusterParameterGroup(ClusterParameterGroup&& value) { m_clusterParameterGroup = std::move(value); }
+
+    
+    inline CreateClusterParameterGroupResult& WithClusterParameterGroup(const ClusterParameterGroup& value) { SetClusterParameterGroup(value); return *this;}
+
+    
+    inline CreateClusterParameterGroupResult& WithClusterParameterGroup(ClusterParameterGroup&& value) { SetClusterParameterGroup(std::move(value)); return *this;}
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline CreateClusterParameterGroupResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline CreateClusterParameterGroupResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    ClusterParameterGroup m_clusterParameterGroup;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

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

@@ -0,0 +1,76 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/model/Cluster.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  class AWS_REDSHIFT_API CreateClusterResult
+  {
+  public:
+    CreateClusterResult();
+    CreateClusterResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    CreateClusterResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    
+    inline const Cluster& GetCluster() const{ return m_cluster; }
+
+    
+    inline void SetCluster(const Cluster& value) { m_cluster = value; }
+
+    
+    inline void SetCluster(Cluster&& value) { m_cluster = std::move(value); }
+
+    
+    inline CreateClusterResult& WithCluster(const Cluster& value) { SetCluster(value); return *this;}
+
+    
+    inline CreateClusterResult& WithCluster(Cluster&& value) { SetCluster(std::move(value)); return *this;}
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline CreateClusterResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline CreateClusterResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    Cluster m_cluster;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/CreateClusterSecurityGroupRequest.h

@@ -0,0 +1,220 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p/><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/CreateClusterSecurityGroupMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API CreateClusterSecurityGroupRequest : public RedshiftRequest
+  {
+  public:
+    CreateClusterSecurityGroupRequest();
+
+    // 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 "CreateClusterSecurityGroup"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The name for the security group. Amazon Redshift stores the value as a
+     * lowercase string.</p> <p>Constraints:</p> <ul> <li> <p>Must contain no more than
+     * 255 alphanumeric characters or hyphens.</p> </li> <li> <p>Must not be
+     * "Default".</p> </li> <li> <p>Must be unique for all security groups that are
+     * created by your AWS account.</p> </li> </ul> <p>Example:
+     * <code>examplesecuritygroup</code> </p>
+     */
+    inline const Aws::String& GetClusterSecurityGroupName() const{ return m_clusterSecurityGroupName; }
+
+    /**
+     * <p>The name for the security group. Amazon Redshift stores the value as a
+     * lowercase string.</p> <p>Constraints:</p> <ul> <li> <p>Must contain no more than
+     * 255 alphanumeric characters or hyphens.</p> </li> <li> <p>Must not be
+     * "Default".</p> </li> <li> <p>Must be unique for all security groups that are
+     * created by your AWS account.</p> </li> </ul> <p>Example:
+     * <code>examplesecuritygroup</code> </p>
+     */
+    inline bool ClusterSecurityGroupNameHasBeenSet() const { return m_clusterSecurityGroupNameHasBeenSet; }
+
+    /**
+     * <p>The name for the security group. Amazon Redshift stores the value as a
+     * lowercase string.</p> <p>Constraints:</p> <ul> <li> <p>Must contain no more than
+     * 255 alphanumeric characters or hyphens.</p> </li> <li> <p>Must not be
+     * "Default".</p> </li> <li> <p>Must be unique for all security groups that are
+     * created by your AWS account.</p> </li> </ul> <p>Example:
+     * <code>examplesecuritygroup</code> </p>
+     */
+    inline void SetClusterSecurityGroupName(const Aws::String& value) { m_clusterSecurityGroupNameHasBeenSet = true; m_clusterSecurityGroupName = value; }
+
+    /**
+     * <p>The name for the security group. Amazon Redshift stores the value as a
+     * lowercase string.</p> <p>Constraints:</p> <ul> <li> <p>Must contain no more than
+     * 255 alphanumeric characters or hyphens.</p> </li> <li> <p>Must not be
+     * "Default".</p> </li> <li> <p>Must be unique for all security groups that are
+     * created by your AWS account.</p> </li> </ul> <p>Example:
+     * <code>examplesecuritygroup</code> </p>
+     */
+    inline void SetClusterSecurityGroupName(Aws::String&& value) { m_clusterSecurityGroupNameHasBeenSet = true; m_clusterSecurityGroupName = std::move(value); }
+
+    /**
+     * <p>The name for the security group. Amazon Redshift stores the value as a
+     * lowercase string.</p> <p>Constraints:</p> <ul> <li> <p>Must contain no more than
+     * 255 alphanumeric characters or hyphens.</p> </li> <li> <p>Must not be
+     * "Default".</p> </li> <li> <p>Must be unique for all security groups that are
+     * created by your AWS account.</p> </li> </ul> <p>Example:
+     * <code>examplesecuritygroup</code> </p>
+     */
+    inline void SetClusterSecurityGroupName(const char* value) { m_clusterSecurityGroupNameHasBeenSet = true; m_clusterSecurityGroupName.assign(value); }
+
+    /**
+     * <p>The name for the security group. Amazon Redshift stores the value as a
+     * lowercase string.</p> <p>Constraints:</p> <ul> <li> <p>Must contain no more than
+     * 255 alphanumeric characters or hyphens.</p> </li> <li> <p>Must not be
+     * "Default".</p> </li> <li> <p>Must be unique for all security groups that are
+     * created by your AWS account.</p> </li> </ul> <p>Example:
+     * <code>examplesecuritygroup</code> </p>
+     */
+    inline CreateClusterSecurityGroupRequest& WithClusterSecurityGroupName(const Aws::String& value) { SetClusterSecurityGroupName(value); return *this;}
+
+    /**
+     * <p>The name for the security group. Amazon Redshift stores the value as a
+     * lowercase string.</p> <p>Constraints:</p> <ul> <li> <p>Must contain no more than
+     * 255 alphanumeric characters or hyphens.</p> </li> <li> <p>Must not be
+     * "Default".</p> </li> <li> <p>Must be unique for all security groups that are
+     * created by your AWS account.</p> </li> </ul> <p>Example:
+     * <code>examplesecuritygroup</code> </p>
+     */
+    inline CreateClusterSecurityGroupRequest& WithClusterSecurityGroupName(Aws::String&& value) { SetClusterSecurityGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name for the security group. Amazon Redshift stores the value as a
+     * lowercase string.</p> <p>Constraints:</p> <ul> <li> <p>Must contain no more than
+     * 255 alphanumeric characters or hyphens.</p> </li> <li> <p>Must not be
+     * "Default".</p> </li> <li> <p>Must be unique for all security groups that are
+     * created by your AWS account.</p> </li> </ul> <p>Example:
+     * <code>examplesecuritygroup</code> </p>
+     */
+    inline CreateClusterSecurityGroupRequest& WithClusterSecurityGroupName(const char* value) { SetClusterSecurityGroupName(value); return *this;}
+
+
+    /**
+     * <p>A description for the security group.</p>
+     */
+    inline const Aws::String& GetDescription() const{ return m_description; }
+
+    /**
+     * <p>A description for the security group.</p>
+     */
+    inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
+
+    /**
+     * <p>A description for the security group.</p>
+     */
+    inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
+
+    /**
+     * <p>A description for the security group.</p>
+     */
+    inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
+
+    /**
+     * <p>A description for the security group.</p>
+     */
+    inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
+
+    /**
+     * <p>A description for the security group.</p>
+     */
+    inline CreateClusterSecurityGroupRequest& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
+
+    /**
+     * <p>A description for the security group.</p>
+     */
+    inline CreateClusterSecurityGroupRequest& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
+
+    /**
+     * <p>A description for the security group.</p>
+     */
+    inline CreateClusterSecurityGroupRequest& WithDescription(const char* value) { SetDescription(value); return *this;}
+
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateClusterSecurityGroupRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateClusterSecurityGroupRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateClusterSecurityGroupRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateClusterSecurityGroupRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_clusterSecurityGroupName;
+    bool m_clusterSecurityGroupNameHasBeenSet;
+
+    Aws::String m_description;
+    bool m_descriptionHasBeenSet;
+
+    Aws::Vector<Tag> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/CreateClusterSecurityGroupResult.h

@@ -0,0 +1,76 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/model/ClusterSecurityGroup.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  class AWS_REDSHIFT_API CreateClusterSecurityGroupResult
+  {
+  public:
+    CreateClusterSecurityGroupResult();
+    CreateClusterSecurityGroupResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    CreateClusterSecurityGroupResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    
+    inline const ClusterSecurityGroup& GetClusterSecurityGroup() const{ return m_clusterSecurityGroup; }
+
+    
+    inline void SetClusterSecurityGroup(const ClusterSecurityGroup& value) { m_clusterSecurityGroup = value; }
+
+    
+    inline void SetClusterSecurityGroup(ClusterSecurityGroup&& value) { m_clusterSecurityGroup = std::move(value); }
+
+    
+    inline CreateClusterSecurityGroupResult& WithClusterSecurityGroup(const ClusterSecurityGroup& value) { SetClusterSecurityGroup(value); return *this;}
+
+    
+    inline CreateClusterSecurityGroupResult& WithClusterSecurityGroup(ClusterSecurityGroup&& value) { SetClusterSecurityGroup(std::move(value)); return *this;}
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline CreateClusterSecurityGroupResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline CreateClusterSecurityGroupResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    ClusterSecurityGroup m_clusterSecurityGroup;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/CreateClusterSnapshotRequest.h

@@ -0,0 +1,252 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p/><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/CreateClusterSnapshotMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API CreateClusterSnapshotRequest : public RedshiftRequest
+  {
+  public:
+    CreateClusterSnapshotRequest();
+
+    // 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 "CreateClusterSnapshot"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>A unique identifier for the snapshot that you are requesting. This identifier
+     * must be unique for all snapshots within the AWS account.</p> <p>Constraints:</p>
+     * <ul> <li> <p>Cannot be null, empty, or blank</p> </li> <li> <p>Must contain from
+     * 1 to 255 alphanumeric characters or hyphens</p> </li> <li> <p>First character
+     * must be a letter</p> </li> <li> <p>Cannot end with a hyphen or contain two
+     * consecutive hyphens</p> </li> </ul> <p>Example: <code>my-snapshot-id</code> </p>
+     */
+    inline const Aws::String& GetSnapshotIdentifier() const{ return m_snapshotIdentifier; }
+
+    /**
+     * <p>A unique identifier for the snapshot that you are requesting. This identifier
+     * must be unique for all snapshots within the AWS account.</p> <p>Constraints:</p>
+     * <ul> <li> <p>Cannot be null, empty, or blank</p> </li> <li> <p>Must contain from
+     * 1 to 255 alphanumeric characters or hyphens</p> </li> <li> <p>First character
+     * must be a letter</p> </li> <li> <p>Cannot end with a hyphen or contain two
+     * consecutive hyphens</p> </li> </ul> <p>Example: <code>my-snapshot-id</code> </p>
+     */
+    inline bool SnapshotIdentifierHasBeenSet() const { return m_snapshotIdentifierHasBeenSet; }
+
+    /**
+     * <p>A unique identifier for the snapshot that you are requesting. This identifier
+     * must be unique for all snapshots within the AWS account.</p> <p>Constraints:</p>
+     * <ul> <li> <p>Cannot be null, empty, or blank</p> </li> <li> <p>Must contain from
+     * 1 to 255 alphanumeric characters or hyphens</p> </li> <li> <p>First character
+     * must be a letter</p> </li> <li> <p>Cannot end with a hyphen or contain two
+     * consecutive hyphens</p> </li> </ul> <p>Example: <code>my-snapshot-id</code> </p>
+     */
+    inline void SetSnapshotIdentifier(const Aws::String& value) { m_snapshotIdentifierHasBeenSet = true; m_snapshotIdentifier = value; }
+
+    /**
+     * <p>A unique identifier for the snapshot that you are requesting. This identifier
+     * must be unique for all snapshots within the AWS account.</p> <p>Constraints:</p>
+     * <ul> <li> <p>Cannot be null, empty, or blank</p> </li> <li> <p>Must contain from
+     * 1 to 255 alphanumeric characters or hyphens</p> </li> <li> <p>First character
+     * must be a letter</p> </li> <li> <p>Cannot end with a hyphen or contain two
+     * consecutive hyphens</p> </li> </ul> <p>Example: <code>my-snapshot-id</code> </p>
+     */
+    inline void SetSnapshotIdentifier(Aws::String&& value) { m_snapshotIdentifierHasBeenSet = true; m_snapshotIdentifier = std::move(value); }
+
+    /**
+     * <p>A unique identifier for the snapshot that you are requesting. This identifier
+     * must be unique for all snapshots within the AWS account.</p> <p>Constraints:</p>
+     * <ul> <li> <p>Cannot be null, empty, or blank</p> </li> <li> <p>Must contain from
+     * 1 to 255 alphanumeric characters or hyphens</p> </li> <li> <p>First character
+     * must be a letter</p> </li> <li> <p>Cannot end with a hyphen or contain two
+     * consecutive hyphens</p> </li> </ul> <p>Example: <code>my-snapshot-id</code> </p>
+     */
+    inline void SetSnapshotIdentifier(const char* value) { m_snapshotIdentifierHasBeenSet = true; m_snapshotIdentifier.assign(value); }
+
+    /**
+     * <p>A unique identifier for the snapshot that you are requesting. This identifier
+     * must be unique for all snapshots within the AWS account.</p> <p>Constraints:</p>
+     * <ul> <li> <p>Cannot be null, empty, or blank</p> </li> <li> <p>Must contain from
+     * 1 to 255 alphanumeric characters or hyphens</p> </li> <li> <p>First character
+     * must be a letter</p> </li> <li> <p>Cannot end with a hyphen or contain two
+     * consecutive hyphens</p> </li> </ul> <p>Example: <code>my-snapshot-id</code> </p>
+     */
+    inline CreateClusterSnapshotRequest& WithSnapshotIdentifier(const Aws::String& value) { SetSnapshotIdentifier(value); return *this;}
+
+    /**
+     * <p>A unique identifier for the snapshot that you are requesting. This identifier
+     * must be unique for all snapshots within the AWS account.</p> <p>Constraints:</p>
+     * <ul> <li> <p>Cannot be null, empty, or blank</p> </li> <li> <p>Must contain from
+     * 1 to 255 alphanumeric characters or hyphens</p> </li> <li> <p>First character
+     * must be a letter</p> </li> <li> <p>Cannot end with a hyphen or contain two
+     * consecutive hyphens</p> </li> </ul> <p>Example: <code>my-snapshot-id</code> </p>
+     */
+    inline CreateClusterSnapshotRequest& WithSnapshotIdentifier(Aws::String&& value) { SetSnapshotIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>A unique identifier for the snapshot that you are requesting. This identifier
+     * must be unique for all snapshots within the AWS account.</p> <p>Constraints:</p>
+     * <ul> <li> <p>Cannot be null, empty, or blank</p> </li> <li> <p>Must contain from
+     * 1 to 255 alphanumeric characters or hyphens</p> </li> <li> <p>First character
+     * must be a letter</p> </li> <li> <p>Cannot end with a hyphen or contain two
+     * consecutive hyphens</p> </li> </ul> <p>Example: <code>my-snapshot-id</code> </p>
+     */
+    inline CreateClusterSnapshotRequest& WithSnapshotIdentifier(const char* value) { SetSnapshotIdentifier(value); return *this;}
+
+
+    /**
+     * <p>The cluster identifier for which you want a snapshot.</p>
+     */
+    inline const Aws::String& GetClusterIdentifier() const{ return m_clusterIdentifier; }
+
+    /**
+     * <p>The cluster identifier for which you want a snapshot.</p>
+     */
+    inline bool ClusterIdentifierHasBeenSet() const { return m_clusterIdentifierHasBeenSet; }
+
+    /**
+     * <p>The cluster identifier for which you want a snapshot.</p>
+     */
+    inline void SetClusterIdentifier(const Aws::String& value) { m_clusterIdentifierHasBeenSet = true; m_clusterIdentifier = value; }
+
+    /**
+     * <p>The cluster identifier for which you want a snapshot.</p>
+     */
+    inline void SetClusterIdentifier(Aws::String&& value) { m_clusterIdentifierHasBeenSet = true; m_clusterIdentifier = std::move(value); }
+
+    /**
+     * <p>The cluster identifier for which you want a snapshot.</p>
+     */
+    inline void SetClusterIdentifier(const char* value) { m_clusterIdentifierHasBeenSet = true; m_clusterIdentifier.assign(value); }
+
+    /**
+     * <p>The cluster identifier for which you want a snapshot.</p>
+     */
+    inline CreateClusterSnapshotRequest& WithClusterIdentifier(const Aws::String& value) { SetClusterIdentifier(value); return *this;}
+
+    /**
+     * <p>The cluster identifier for which you want a snapshot.</p>
+     */
+    inline CreateClusterSnapshotRequest& WithClusterIdentifier(Aws::String&& value) { SetClusterIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>The cluster identifier for which you want a snapshot.</p>
+     */
+    inline CreateClusterSnapshotRequest& WithClusterIdentifier(const char* value) { SetClusterIdentifier(value); return *this;}
+
+
+    /**
+     * <p>The number of days that a manual snapshot is retained. If the value is -1,
+     * the manual snapshot is retained indefinitely. </p> <p>The value must be either
+     * -1 or an integer between 1 and 3,653.</p> <p>The default value is -1.</p>
+     */
+    inline int GetManualSnapshotRetentionPeriod() const{ return m_manualSnapshotRetentionPeriod; }
+
+    /**
+     * <p>The number of days that a manual snapshot is retained. If the value is -1,
+     * the manual snapshot is retained indefinitely. </p> <p>The value must be either
+     * -1 or an integer between 1 and 3,653.</p> <p>The default value is -1.</p>
+     */
+    inline bool ManualSnapshotRetentionPeriodHasBeenSet() const { return m_manualSnapshotRetentionPeriodHasBeenSet; }
+
+    /**
+     * <p>The number of days that a manual snapshot is retained. If the value is -1,
+     * the manual snapshot is retained indefinitely. </p> <p>The value must be either
+     * -1 or an integer between 1 and 3,653.</p> <p>The default value is -1.</p>
+     */
+    inline void SetManualSnapshotRetentionPeriod(int value) { m_manualSnapshotRetentionPeriodHasBeenSet = true; m_manualSnapshotRetentionPeriod = value; }
+
+    /**
+     * <p>The number of days that a manual snapshot is retained. If the value is -1,
+     * the manual snapshot is retained indefinitely. </p> <p>The value must be either
+     * -1 or an integer between 1 and 3,653.</p> <p>The default value is -1.</p>
+     */
+    inline CreateClusterSnapshotRequest& WithManualSnapshotRetentionPeriod(int value) { SetManualSnapshotRetentionPeriod(value); return *this;}
+
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateClusterSnapshotRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateClusterSnapshotRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateClusterSnapshotRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateClusterSnapshotRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_snapshotIdentifier;
+    bool m_snapshotIdentifierHasBeenSet;
+
+    Aws::String m_clusterIdentifier;
+    bool m_clusterIdentifierHasBeenSet;
+
+    int m_manualSnapshotRetentionPeriod;
+    bool m_manualSnapshotRetentionPeriodHasBeenSet;
+
+    Aws::Vector<Tag> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/CreateClusterSnapshotResult.h

@@ -0,0 +1,76 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/model/Snapshot.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  class AWS_REDSHIFT_API CreateClusterSnapshotResult
+  {
+  public:
+    CreateClusterSnapshotResult();
+    CreateClusterSnapshotResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    CreateClusterSnapshotResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    
+    inline const Snapshot& GetSnapshot() const{ return m_snapshot; }
+
+    
+    inline void SetSnapshot(const Snapshot& value) { m_snapshot = value; }
+
+    
+    inline void SetSnapshot(Snapshot&& value) { m_snapshot = std::move(value); }
+
+    
+    inline CreateClusterSnapshotResult& WithSnapshot(const Snapshot& value) { SetSnapshot(value); return *this;}
+
+    
+    inline CreateClusterSnapshotResult& WithSnapshot(Snapshot&& value) { SetSnapshot(std::move(value)); return *this;}
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline CreateClusterSnapshotResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline CreateClusterSnapshotResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    Snapshot m_snapshot;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/CreateClusterSubnetGroupRequest.h

@@ -0,0 +1,278 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p/><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/CreateClusterSubnetGroupMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API CreateClusterSubnetGroupRequest : public RedshiftRequest
+  {
+  public:
+    CreateClusterSubnetGroupRequest();
+
+    // 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 "CreateClusterSubnetGroup"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The name for the subnet group. Amazon Redshift stores the value as a
+     * lowercase string.</p> <p>Constraints:</p> <ul> <li> <p>Must contain no more than
+     * 255 alphanumeric characters or hyphens.</p> </li> <li> <p>Must not be
+     * "Default".</p> </li> <li> <p>Must be unique for all subnet groups that are
+     * created by your AWS account.</p> </li> </ul> <p>Example:
+     * <code>examplesubnetgroup</code> </p>
+     */
+    inline const Aws::String& GetClusterSubnetGroupName() const{ return m_clusterSubnetGroupName; }
+
+    /**
+     * <p>The name for the subnet group. Amazon Redshift stores the value as a
+     * lowercase string.</p> <p>Constraints:</p> <ul> <li> <p>Must contain no more than
+     * 255 alphanumeric characters or hyphens.</p> </li> <li> <p>Must not be
+     * "Default".</p> </li> <li> <p>Must be unique for all subnet groups that are
+     * created by your AWS account.</p> </li> </ul> <p>Example:
+     * <code>examplesubnetgroup</code> </p>
+     */
+    inline bool ClusterSubnetGroupNameHasBeenSet() const { return m_clusterSubnetGroupNameHasBeenSet; }
+
+    /**
+     * <p>The name for the subnet group. Amazon Redshift stores the value as a
+     * lowercase string.</p> <p>Constraints:</p> <ul> <li> <p>Must contain no more than
+     * 255 alphanumeric characters or hyphens.</p> </li> <li> <p>Must not be
+     * "Default".</p> </li> <li> <p>Must be unique for all subnet groups that are
+     * created by your AWS account.</p> </li> </ul> <p>Example:
+     * <code>examplesubnetgroup</code> </p>
+     */
+    inline void SetClusterSubnetGroupName(const Aws::String& value) { m_clusterSubnetGroupNameHasBeenSet = true; m_clusterSubnetGroupName = value; }
+
+    /**
+     * <p>The name for the subnet group. Amazon Redshift stores the value as a
+     * lowercase string.</p> <p>Constraints:</p> <ul> <li> <p>Must contain no more than
+     * 255 alphanumeric characters or hyphens.</p> </li> <li> <p>Must not be
+     * "Default".</p> </li> <li> <p>Must be unique for all subnet groups that are
+     * created by your AWS account.</p> </li> </ul> <p>Example:
+     * <code>examplesubnetgroup</code> </p>
+     */
+    inline void SetClusterSubnetGroupName(Aws::String&& value) { m_clusterSubnetGroupNameHasBeenSet = true; m_clusterSubnetGroupName = std::move(value); }
+
+    /**
+     * <p>The name for the subnet group. Amazon Redshift stores the value as a
+     * lowercase string.</p> <p>Constraints:</p> <ul> <li> <p>Must contain no more than
+     * 255 alphanumeric characters or hyphens.</p> </li> <li> <p>Must not be
+     * "Default".</p> </li> <li> <p>Must be unique for all subnet groups that are
+     * created by your AWS account.</p> </li> </ul> <p>Example:
+     * <code>examplesubnetgroup</code> </p>
+     */
+    inline void SetClusterSubnetGroupName(const char* value) { m_clusterSubnetGroupNameHasBeenSet = true; m_clusterSubnetGroupName.assign(value); }
+
+    /**
+     * <p>The name for the subnet group. Amazon Redshift stores the value as a
+     * lowercase string.</p> <p>Constraints:</p> <ul> <li> <p>Must contain no more than
+     * 255 alphanumeric characters or hyphens.</p> </li> <li> <p>Must not be
+     * "Default".</p> </li> <li> <p>Must be unique for all subnet groups that are
+     * created by your AWS account.</p> </li> </ul> <p>Example:
+     * <code>examplesubnetgroup</code> </p>
+     */
+    inline CreateClusterSubnetGroupRequest& WithClusterSubnetGroupName(const Aws::String& value) { SetClusterSubnetGroupName(value); return *this;}
+
+    /**
+     * <p>The name for the subnet group. Amazon Redshift stores the value as a
+     * lowercase string.</p> <p>Constraints:</p> <ul> <li> <p>Must contain no more than
+     * 255 alphanumeric characters or hyphens.</p> </li> <li> <p>Must not be
+     * "Default".</p> </li> <li> <p>Must be unique for all subnet groups that are
+     * created by your AWS account.</p> </li> </ul> <p>Example:
+     * <code>examplesubnetgroup</code> </p>
+     */
+    inline CreateClusterSubnetGroupRequest& WithClusterSubnetGroupName(Aws::String&& value) { SetClusterSubnetGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name for the subnet group. Amazon Redshift stores the value as a
+     * lowercase string.</p> <p>Constraints:</p> <ul> <li> <p>Must contain no more than
+     * 255 alphanumeric characters or hyphens.</p> </li> <li> <p>Must not be
+     * "Default".</p> </li> <li> <p>Must be unique for all subnet groups that are
+     * created by your AWS account.</p> </li> </ul> <p>Example:
+     * <code>examplesubnetgroup</code> </p>
+     */
+    inline CreateClusterSubnetGroupRequest& WithClusterSubnetGroupName(const char* value) { SetClusterSubnetGroupName(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 CreateClusterSubnetGroupRequest& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
+
+    /**
+     * <p>A description for the subnet group.</p>
+     */
+    inline CreateClusterSubnetGroupRequest& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
+
+    /**
+     * <p>A description for the subnet group.</p>
+     */
+    inline CreateClusterSubnetGroupRequest& WithDescription(const char* value) { SetDescription(value); return *this;}
+
+
+    /**
+     * <p>An array of VPC subnet IDs. A maximum of 20 subnets can be modified in a
+     * single request.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetSubnetIds() const{ return m_subnetIds; }
+
+    /**
+     * <p>An array of VPC subnet IDs. A maximum of 20 subnets can be modified in a
+     * single request.</p>
+     */
+    inline bool SubnetIdsHasBeenSet() const { return m_subnetIdsHasBeenSet; }
+
+    /**
+     * <p>An array of VPC subnet IDs. A maximum of 20 subnets can be modified in a
+     * single request.</p>
+     */
+    inline void SetSubnetIds(const Aws::Vector<Aws::String>& value) { m_subnetIdsHasBeenSet = true; m_subnetIds = value; }
+
+    /**
+     * <p>An array of VPC subnet IDs. A maximum of 20 subnets can be modified in a
+     * single request.</p>
+     */
+    inline void SetSubnetIds(Aws::Vector<Aws::String>&& value) { m_subnetIdsHasBeenSet = true; m_subnetIds = std::move(value); }
+
+    /**
+     * <p>An array of VPC subnet IDs. A maximum of 20 subnets can be modified in a
+     * single request.</p>
+     */
+    inline CreateClusterSubnetGroupRequest& WithSubnetIds(const Aws::Vector<Aws::String>& value) { SetSubnetIds(value); return *this;}
+
+    /**
+     * <p>An array of VPC subnet IDs. A maximum of 20 subnets can be modified in a
+     * single request.</p>
+     */
+    inline CreateClusterSubnetGroupRequest& WithSubnetIds(Aws::Vector<Aws::String>&& value) { SetSubnetIds(std::move(value)); return *this;}
+
+    /**
+     * <p>An array of VPC subnet IDs. A maximum of 20 subnets can be modified in a
+     * single request.</p>
+     */
+    inline CreateClusterSubnetGroupRequest& AddSubnetIds(const Aws::String& value) { m_subnetIdsHasBeenSet = true; m_subnetIds.push_back(value); return *this; }
+
+    /**
+     * <p>An array of VPC subnet IDs. A maximum of 20 subnets can be modified in a
+     * single request.</p>
+     */
+    inline CreateClusterSubnetGroupRequest& AddSubnetIds(Aws::String&& value) { m_subnetIdsHasBeenSet = true; m_subnetIds.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>An array of VPC subnet IDs. A maximum of 20 subnets can be modified in a
+     * single request.</p>
+     */
+    inline CreateClusterSubnetGroupRequest& AddSubnetIds(const char* value) { m_subnetIdsHasBeenSet = true; m_subnetIds.push_back(value); return *this; }
+
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateClusterSubnetGroupRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateClusterSubnetGroupRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateClusterSubnetGroupRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateClusterSubnetGroupRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_clusterSubnetGroupName;
+    bool m_clusterSubnetGroupNameHasBeenSet;
+
+    Aws::String m_description;
+    bool m_descriptionHasBeenSet;
+
+    Aws::Vector<Aws::String> m_subnetIds;
+    bool m_subnetIdsHasBeenSet;
+
+    Aws::Vector<Tag> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/CreateClusterSubnetGroupResult.h

@@ -0,0 +1,76 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/model/ClusterSubnetGroup.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  class AWS_REDSHIFT_API CreateClusterSubnetGroupResult
+  {
+  public:
+    CreateClusterSubnetGroupResult();
+    CreateClusterSubnetGroupResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    CreateClusterSubnetGroupResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    
+    inline const ClusterSubnetGroup& GetClusterSubnetGroup() const{ return m_clusterSubnetGroup; }
+
+    
+    inline void SetClusterSubnetGroup(const ClusterSubnetGroup& value) { m_clusterSubnetGroup = value; }
+
+    
+    inline void SetClusterSubnetGroup(ClusterSubnetGroup&& value) { m_clusterSubnetGroup = std::move(value); }
+
+    
+    inline CreateClusterSubnetGroupResult& WithClusterSubnetGroup(const ClusterSubnetGroup& value) { SetClusterSubnetGroup(value); return *this;}
+
+    
+    inline CreateClusterSubnetGroupResult& WithClusterSubnetGroup(ClusterSubnetGroup&& value) { SetClusterSubnetGroup(std::move(value)); return *this;}
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline CreateClusterSubnetGroupResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline CreateClusterSubnetGroupResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    ClusterSubnetGroup m_clusterSubnetGroup;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/CreateEventSubscriptionRequest.h

@@ -0,0 +1,561 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p/><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/CreateEventSubscriptionMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API CreateEventSubscriptionRequest : public RedshiftRequest
+  {
+  public:
+    CreateEventSubscriptionRequest();
+
+    // 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 "CreateEventSubscription"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The name of the event subscription to be created.</p> <p>Constraints:</p>
+     * <ul> <li> <p>Cannot be null, empty, or blank.</p> </li> <li> <p>Must contain
+     * from 1 to 255 alphanumeric characters or hyphens.</p> </li> <li> <p>First
+     * character must be a letter.</p> </li> <li> <p>Cannot end with a hyphen or
+     * contain two consecutive hyphens.</p> </li> </ul>
+     */
+    inline const Aws::String& GetSubscriptionName() const{ return m_subscriptionName; }
+
+    /**
+     * <p>The name of the event subscription to be created.</p> <p>Constraints:</p>
+     * <ul> <li> <p>Cannot be null, empty, or blank.</p> </li> <li> <p>Must contain
+     * from 1 to 255 alphanumeric characters or hyphens.</p> </li> <li> <p>First
+     * character must be a letter.</p> </li> <li> <p>Cannot end with a hyphen or
+     * contain two consecutive hyphens.</p> </li> </ul>
+     */
+    inline bool SubscriptionNameHasBeenSet() const { return m_subscriptionNameHasBeenSet; }
+
+    /**
+     * <p>The name of the event subscription to be created.</p> <p>Constraints:</p>
+     * <ul> <li> <p>Cannot be null, empty, or blank.</p> </li> <li> <p>Must contain
+     * from 1 to 255 alphanumeric characters or hyphens.</p> </li> <li> <p>First
+     * character must be a letter.</p> </li> <li> <p>Cannot end with a hyphen or
+     * contain two consecutive hyphens.</p> </li> </ul>
+     */
+    inline void SetSubscriptionName(const Aws::String& value) { m_subscriptionNameHasBeenSet = true; m_subscriptionName = value; }
+
+    /**
+     * <p>The name of the event subscription to be created.</p> <p>Constraints:</p>
+     * <ul> <li> <p>Cannot be null, empty, or blank.</p> </li> <li> <p>Must contain
+     * from 1 to 255 alphanumeric characters or hyphens.</p> </li> <li> <p>First
+     * character must be a letter.</p> </li> <li> <p>Cannot end with a hyphen or
+     * contain two consecutive hyphens.</p> </li> </ul>
+     */
+    inline void SetSubscriptionName(Aws::String&& value) { m_subscriptionNameHasBeenSet = true; m_subscriptionName = std::move(value); }
+
+    /**
+     * <p>The name of the event subscription to be created.</p> <p>Constraints:</p>
+     * <ul> <li> <p>Cannot be null, empty, or blank.</p> </li> <li> <p>Must contain
+     * from 1 to 255 alphanumeric characters or hyphens.</p> </li> <li> <p>First
+     * character must be a letter.</p> </li> <li> <p>Cannot end with a hyphen or
+     * contain two consecutive hyphens.</p> </li> </ul>
+     */
+    inline void SetSubscriptionName(const char* value) { m_subscriptionNameHasBeenSet = true; m_subscriptionName.assign(value); }
+
+    /**
+     * <p>The name of the event subscription to be created.</p> <p>Constraints:</p>
+     * <ul> <li> <p>Cannot be null, empty, or blank.</p> </li> <li> <p>Must contain
+     * from 1 to 255 alphanumeric characters or hyphens.</p> </li> <li> <p>First
+     * character must be a letter.</p> </li> <li> <p>Cannot end with a hyphen or
+     * contain two consecutive hyphens.</p> </li> </ul>
+     */
+    inline CreateEventSubscriptionRequest& WithSubscriptionName(const Aws::String& value) { SetSubscriptionName(value); return *this;}
+
+    /**
+     * <p>The name of the event subscription to be created.</p> <p>Constraints:</p>
+     * <ul> <li> <p>Cannot be null, empty, or blank.</p> </li> <li> <p>Must contain
+     * from 1 to 255 alphanumeric characters or hyphens.</p> </li> <li> <p>First
+     * character must be a letter.</p> </li> <li> <p>Cannot end with a hyphen or
+     * contain two consecutive hyphens.</p> </li> </ul>
+     */
+    inline CreateEventSubscriptionRequest& WithSubscriptionName(Aws::String&& value) { SetSubscriptionName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the event subscription to be created.</p> <p>Constraints:</p>
+     * <ul> <li> <p>Cannot be null, empty, or blank.</p> </li> <li> <p>Must contain
+     * from 1 to 255 alphanumeric characters or hyphens.</p> </li> <li> <p>First
+     * character must be a letter.</p> </li> <li> <p>Cannot end with a hyphen or
+     * contain two consecutive hyphens.</p> </li> </ul>
+     */
+    inline CreateEventSubscriptionRequest& WithSubscriptionName(const char* value) { SetSubscriptionName(value); return *this;}
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the Amazon SNS topic used to transmit the
+     * event notifications. The ARN is created by Amazon SNS when you create a topic
+     * and subscribe to it.</p>
+     */
+    inline const Aws::String& GetSnsTopicArn() const{ return m_snsTopicArn; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the Amazon SNS topic used to transmit the
+     * event notifications. The ARN is created by Amazon SNS when you create a topic
+     * and subscribe to it.</p>
+     */
+    inline bool SnsTopicArnHasBeenSet() const { return m_snsTopicArnHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the Amazon SNS topic used to transmit the
+     * event notifications. The ARN is created by Amazon SNS when you create a topic
+     * and subscribe to it.</p>
+     */
+    inline void SetSnsTopicArn(const Aws::String& value) { m_snsTopicArnHasBeenSet = true; m_snsTopicArn = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the Amazon SNS topic used to transmit the
+     * event notifications. The ARN is created by Amazon SNS when you create a topic
+     * and subscribe to it.</p>
+     */
+    inline void SetSnsTopicArn(Aws::String&& value) { m_snsTopicArnHasBeenSet = true; m_snsTopicArn = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the Amazon SNS topic used to transmit the
+     * event notifications. The ARN is created by Amazon SNS when you create a topic
+     * and subscribe to it.</p>
+     */
+    inline void SetSnsTopicArn(const char* value) { m_snsTopicArnHasBeenSet = true; m_snsTopicArn.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the Amazon SNS topic used to transmit the
+     * event notifications. The ARN is created by Amazon SNS when you create a topic
+     * and subscribe to it.</p>
+     */
+    inline CreateEventSubscriptionRequest& WithSnsTopicArn(const Aws::String& value) { SetSnsTopicArn(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the Amazon SNS topic used to transmit the
+     * event notifications. The ARN is created by Amazon SNS when you create a topic
+     * and subscribe to it.</p>
+     */
+    inline CreateEventSubscriptionRequest& WithSnsTopicArn(Aws::String&& value) { SetSnsTopicArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the Amazon SNS topic used to transmit the
+     * event notifications. The ARN is created by Amazon SNS when you create a topic
+     * and subscribe to it.</p>
+     */
+    inline CreateEventSubscriptionRequest& WithSnsTopicArn(const char* value) { SetSnsTopicArn(value); return *this;}
+
+
+    /**
+     * <p>The type of source that will be generating the events. For example, if you
+     * want to be notified of events generated by a cluster, you would set this
+     * parameter to cluster. If this value is not specified, events are returned for
+     * all Amazon Redshift objects in your AWS account. You must specify a source type
+     * in order to specify source IDs.</p> <p>Valid values: cluster,
+     * cluster-parameter-group, cluster-security-group, cluster-snapshot, and
+     * scheduled-action.</p>
+     */
+    inline const Aws::String& GetSourceType() const{ return m_sourceType; }
+
+    /**
+     * <p>The type of source that will be generating the events. For example, if you
+     * want to be notified of events generated by a cluster, you would set this
+     * parameter to cluster. If this value is not specified, events are returned for
+     * all Amazon Redshift objects in your AWS account. You must specify a source type
+     * in order to specify source IDs.</p> <p>Valid values: cluster,
+     * cluster-parameter-group, cluster-security-group, cluster-snapshot, and
+     * scheduled-action.</p>
+     */
+    inline bool SourceTypeHasBeenSet() const { return m_sourceTypeHasBeenSet; }
+
+    /**
+     * <p>The type of source that will be generating the events. For example, if you
+     * want to be notified of events generated by a cluster, you would set this
+     * parameter to cluster. If this value is not specified, events are returned for
+     * all Amazon Redshift objects in your AWS account. You must specify a source type
+     * in order to specify source IDs.</p> <p>Valid values: cluster,
+     * cluster-parameter-group, cluster-security-group, cluster-snapshot, and
+     * scheduled-action.</p>
+     */
+    inline void SetSourceType(const Aws::String& value) { m_sourceTypeHasBeenSet = true; m_sourceType = value; }
+
+    /**
+     * <p>The type of source that will be generating the events. For example, if you
+     * want to be notified of events generated by a cluster, you would set this
+     * parameter to cluster. If this value is not specified, events are returned for
+     * all Amazon Redshift objects in your AWS account. You must specify a source type
+     * in order to specify source IDs.</p> <p>Valid values: cluster,
+     * cluster-parameter-group, cluster-security-group, cluster-snapshot, and
+     * scheduled-action.</p>
+     */
+    inline void SetSourceType(Aws::String&& value) { m_sourceTypeHasBeenSet = true; m_sourceType = std::move(value); }
+
+    /**
+     * <p>The type of source that will be generating the events. For example, if you
+     * want to be notified of events generated by a cluster, you would set this
+     * parameter to cluster. If this value is not specified, events are returned for
+     * all Amazon Redshift objects in your AWS account. You must specify a source type
+     * in order to specify source IDs.</p> <p>Valid values: cluster,
+     * cluster-parameter-group, cluster-security-group, cluster-snapshot, and
+     * scheduled-action.</p>
+     */
+    inline void SetSourceType(const char* value) { m_sourceTypeHasBeenSet = true; m_sourceType.assign(value); }
+
+    /**
+     * <p>The type of source that will be generating the events. For example, if you
+     * want to be notified of events generated by a cluster, you would set this
+     * parameter to cluster. If this value is not specified, events are returned for
+     * all Amazon Redshift objects in your AWS account. You must specify a source type
+     * in order to specify source IDs.</p> <p>Valid values: cluster,
+     * cluster-parameter-group, cluster-security-group, cluster-snapshot, and
+     * scheduled-action.</p>
+     */
+    inline CreateEventSubscriptionRequest& WithSourceType(const Aws::String& value) { SetSourceType(value); return *this;}
+
+    /**
+     * <p>The type of source that will be generating the events. For example, if you
+     * want to be notified of events generated by a cluster, you would set this
+     * parameter to cluster. If this value is not specified, events are returned for
+     * all Amazon Redshift objects in your AWS account. You must specify a source type
+     * in order to specify source IDs.</p> <p>Valid values: cluster,
+     * cluster-parameter-group, cluster-security-group, cluster-snapshot, and
+     * scheduled-action.</p>
+     */
+    inline CreateEventSubscriptionRequest& WithSourceType(Aws::String&& value) { SetSourceType(std::move(value)); return *this;}
+
+    /**
+     * <p>The type of source that will be generating the events. For example, if you
+     * want to be notified of events generated by a cluster, you would set this
+     * parameter to cluster. If this value is not specified, events are returned for
+     * all Amazon Redshift objects in your AWS account. You must specify a source type
+     * in order to specify source IDs.</p> <p>Valid values: cluster,
+     * cluster-parameter-group, cluster-security-group, cluster-snapshot, and
+     * scheduled-action.</p>
+     */
+    inline CreateEventSubscriptionRequest& WithSourceType(const char* value) { SetSourceType(value); return *this;}
+
+
+    /**
+     * <p>A list of one or more identifiers of Amazon Redshift source objects. All of
+     * the objects must be of the same type as was specified in the source type
+     * parameter. The event subscription will return only events generated by the
+     * specified objects. If not specified, then events are returned for all objects
+     * within the source type specified.</p> <p>Example: my-cluster-1, my-cluster-2</p>
+     * <p>Example: my-snapshot-20131010</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetSourceIds() const{ return m_sourceIds; }
+
+    /**
+     * <p>A list of one or more identifiers of Amazon Redshift source objects. All of
+     * the objects must be of the same type as was specified in the source type
+     * parameter. The event subscription will return only events generated by the
+     * specified objects. If not specified, then events are returned for all objects
+     * within the source type specified.</p> <p>Example: my-cluster-1, my-cluster-2</p>
+     * <p>Example: my-snapshot-20131010</p>
+     */
+    inline bool SourceIdsHasBeenSet() const { return m_sourceIdsHasBeenSet; }
+
+    /**
+     * <p>A list of one or more identifiers of Amazon Redshift source objects. All of
+     * the objects must be of the same type as was specified in the source type
+     * parameter. The event subscription will return only events generated by the
+     * specified objects. If not specified, then events are returned for all objects
+     * within the source type specified.</p> <p>Example: my-cluster-1, my-cluster-2</p>
+     * <p>Example: my-snapshot-20131010</p>
+     */
+    inline void SetSourceIds(const Aws::Vector<Aws::String>& value) { m_sourceIdsHasBeenSet = true; m_sourceIds = value; }
+
+    /**
+     * <p>A list of one or more identifiers of Amazon Redshift source objects. All of
+     * the objects must be of the same type as was specified in the source type
+     * parameter. The event subscription will return only events generated by the
+     * specified objects. If not specified, then events are returned for all objects
+     * within the source type specified.</p> <p>Example: my-cluster-1, my-cluster-2</p>
+     * <p>Example: my-snapshot-20131010</p>
+     */
+    inline void SetSourceIds(Aws::Vector<Aws::String>&& value) { m_sourceIdsHasBeenSet = true; m_sourceIds = std::move(value); }
+
+    /**
+     * <p>A list of one or more identifiers of Amazon Redshift source objects. All of
+     * the objects must be of the same type as was specified in the source type
+     * parameter. The event subscription will return only events generated by the
+     * specified objects. If not specified, then events are returned for all objects
+     * within the source type specified.</p> <p>Example: my-cluster-1, my-cluster-2</p>
+     * <p>Example: my-snapshot-20131010</p>
+     */
+    inline CreateEventSubscriptionRequest& WithSourceIds(const Aws::Vector<Aws::String>& value) { SetSourceIds(value); return *this;}
+
+    /**
+     * <p>A list of one or more identifiers of Amazon Redshift source objects. All of
+     * the objects must be of the same type as was specified in the source type
+     * parameter. The event subscription will return only events generated by the
+     * specified objects. If not specified, then events are returned for all objects
+     * within the source type specified.</p> <p>Example: my-cluster-1, my-cluster-2</p>
+     * <p>Example: my-snapshot-20131010</p>
+     */
+    inline CreateEventSubscriptionRequest& WithSourceIds(Aws::Vector<Aws::String>&& value) { SetSourceIds(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of one or more identifiers of Amazon Redshift source objects. All of
+     * the objects must be of the same type as was specified in the source type
+     * parameter. The event subscription will return only events generated by the
+     * specified objects. If not specified, then events are returned for all objects
+     * within the source type specified.</p> <p>Example: my-cluster-1, my-cluster-2</p>
+     * <p>Example: my-snapshot-20131010</p>
+     */
+    inline CreateEventSubscriptionRequest& AddSourceIds(const Aws::String& value) { m_sourceIdsHasBeenSet = true; m_sourceIds.push_back(value); return *this; }
+
+    /**
+     * <p>A list of one or more identifiers of Amazon Redshift source objects. All of
+     * the objects must be of the same type as was specified in the source type
+     * parameter. The event subscription will return only events generated by the
+     * specified objects. If not specified, then events are returned for all objects
+     * within the source type specified.</p> <p>Example: my-cluster-1, my-cluster-2</p>
+     * <p>Example: my-snapshot-20131010</p>
+     */
+    inline CreateEventSubscriptionRequest& AddSourceIds(Aws::String&& value) { m_sourceIdsHasBeenSet = true; m_sourceIds.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>A list of one or more identifiers of Amazon Redshift source objects. All of
+     * the objects must be of the same type as was specified in the source type
+     * parameter. The event subscription will return only events generated by the
+     * specified objects. If not specified, then events are returned for all objects
+     * within the source type specified.</p> <p>Example: my-cluster-1, my-cluster-2</p>
+     * <p>Example: my-snapshot-20131010</p>
+     */
+    inline CreateEventSubscriptionRequest& AddSourceIds(const char* value) { m_sourceIdsHasBeenSet = true; m_sourceIds.push_back(value); return *this; }
+
+
+    /**
+     * <p>Specifies the Amazon Redshift event categories to be published by the event
+     * notification subscription.</p> <p>Values: configuration, management, monitoring,
+     * security</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetEventCategories() const{ return m_eventCategories; }
+
+    /**
+     * <p>Specifies the Amazon Redshift event categories to be published by the event
+     * notification subscription.</p> <p>Values: configuration, management, monitoring,
+     * security</p>
+     */
+    inline bool EventCategoriesHasBeenSet() const { return m_eventCategoriesHasBeenSet; }
+
+    /**
+     * <p>Specifies the Amazon Redshift event categories to be published by the event
+     * notification subscription.</p> <p>Values: configuration, management, monitoring,
+     * security</p>
+     */
+    inline void SetEventCategories(const Aws::Vector<Aws::String>& value) { m_eventCategoriesHasBeenSet = true; m_eventCategories = value; }
+
+    /**
+     * <p>Specifies the Amazon Redshift event categories to be published by the event
+     * notification subscription.</p> <p>Values: configuration, management, monitoring,
+     * security</p>
+     */
+    inline void SetEventCategories(Aws::Vector<Aws::String>&& value) { m_eventCategoriesHasBeenSet = true; m_eventCategories = std::move(value); }
+
+    /**
+     * <p>Specifies the Amazon Redshift event categories to be published by the event
+     * notification subscription.</p> <p>Values: configuration, management, monitoring,
+     * security</p>
+     */
+    inline CreateEventSubscriptionRequest& WithEventCategories(const Aws::Vector<Aws::String>& value) { SetEventCategories(value); return *this;}
+
+    /**
+     * <p>Specifies the Amazon Redshift event categories to be published by the event
+     * notification subscription.</p> <p>Values: configuration, management, monitoring,
+     * security</p>
+     */
+    inline CreateEventSubscriptionRequest& WithEventCategories(Aws::Vector<Aws::String>&& value) { SetEventCategories(std::move(value)); return *this;}
+
+    /**
+     * <p>Specifies the Amazon Redshift event categories to be published by the event
+     * notification subscription.</p> <p>Values: configuration, management, monitoring,
+     * security</p>
+     */
+    inline CreateEventSubscriptionRequest& AddEventCategories(const Aws::String& value) { m_eventCategoriesHasBeenSet = true; m_eventCategories.push_back(value); return *this; }
+
+    /**
+     * <p>Specifies the Amazon Redshift event categories to be published by the event
+     * notification subscription.</p> <p>Values: configuration, management, monitoring,
+     * security</p>
+     */
+    inline CreateEventSubscriptionRequest& AddEventCategories(Aws::String&& value) { m_eventCategoriesHasBeenSet = true; m_eventCategories.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>Specifies the Amazon Redshift event categories to be published by the event
+     * notification subscription.</p> <p>Values: configuration, management, monitoring,
+     * security</p>
+     */
+    inline CreateEventSubscriptionRequest& AddEventCategories(const char* value) { m_eventCategoriesHasBeenSet = true; m_eventCategories.push_back(value); return *this; }
+
+
+    /**
+     * <p>Specifies the Amazon Redshift event severity to be published by the event
+     * notification subscription.</p> <p>Values: ERROR, INFO</p>
+     */
+    inline const Aws::String& GetSeverity() const{ return m_severity; }
+
+    /**
+     * <p>Specifies the Amazon Redshift event severity to be published by the event
+     * notification subscription.</p> <p>Values: ERROR, INFO</p>
+     */
+    inline bool SeverityHasBeenSet() const { return m_severityHasBeenSet; }
+
+    /**
+     * <p>Specifies the Amazon Redshift event severity to be published by the event
+     * notification subscription.</p> <p>Values: ERROR, INFO</p>
+     */
+    inline void SetSeverity(const Aws::String& value) { m_severityHasBeenSet = true; m_severity = value; }
+
+    /**
+     * <p>Specifies the Amazon Redshift event severity to be published by the event
+     * notification subscription.</p> <p>Values: ERROR, INFO</p>
+     */
+    inline void SetSeverity(Aws::String&& value) { m_severityHasBeenSet = true; m_severity = std::move(value); }
+
+    /**
+     * <p>Specifies the Amazon Redshift event severity to be published by the event
+     * notification subscription.</p> <p>Values: ERROR, INFO</p>
+     */
+    inline void SetSeverity(const char* value) { m_severityHasBeenSet = true; m_severity.assign(value); }
+
+    /**
+     * <p>Specifies the Amazon Redshift event severity to be published by the event
+     * notification subscription.</p> <p>Values: ERROR, INFO</p>
+     */
+    inline CreateEventSubscriptionRequest& WithSeverity(const Aws::String& value) { SetSeverity(value); return *this;}
+
+    /**
+     * <p>Specifies the Amazon Redshift event severity to be published by the event
+     * notification subscription.</p> <p>Values: ERROR, INFO</p>
+     */
+    inline CreateEventSubscriptionRequest& WithSeverity(Aws::String&& value) { SetSeverity(std::move(value)); return *this;}
+
+    /**
+     * <p>Specifies the Amazon Redshift event severity to be published by the event
+     * notification subscription.</p> <p>Values: ERROR, INFO</p>
+     */
+    inline CreateEventSubscriptionRequest& WithSeverity(const char* value) { SetSeverity(value); return *this;}
+
+
+    /**
+     * <p>A boolean value; set to <code>true</code> to activate the subscription, and
+     * set to <code>false</code> to create the subscription but not activate it. </p>
+     */
+    inline bool GetEnabled() const{ return m_enabled; }
+
+    /**
+     * <p>A boolean value; set to <code>true</code> to activate the subscription, and
+     * set to <code>false</code> to create the subscription but not activate it. </p>
+     */
+    inline bool EnabledHasBeenSet() const { return m_enabledHasBeenSet; }
+
+    /**
+     * <p>A boolean value; set to <code>true</code> to activate the subscription, and
+     * set to <code>false</code> to create the subscription but not activate it. </p>
+     */
+    inline void SetEnabled(bool value) { m_enabledHasBeenSet = true; m_enabled = value; }
+
+    /**
+     * <p>A boolean value; set to <code>true</code> to activate the subscription, and
+     * set to <code>false</code> to create the subscription but not activate it. </p>
+     */
+    inline CreateEventSubscriptionRequest& WithEnabled(bool value) { SetEnabled(value); return *this;}
+
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateEventSubscriptionRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateEventSubscriptionRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateEventSubscriptionRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateEventSubscriptionRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_subscriptionName;
+    bool m_subscriptionNameHasBeenSet;
+
+    Aws::String m_snsTopicArn;
+    bool m_snsTopicArnHasBeenSet;
+
+    Aws::String m_sourceType;
+    bool m_sourceTypeHasBeenSet;
+
+    Aws::Vector<Aws::String> m_sourceIds;
+    bool m_sourceIdsHasBeenSet;
+
+    Aws::Vector<Aws::String> m_eventCategories;
+    bool m_eventCategoriesHasBeenSet;
+
+    Aws::String m_severity;
+    bool m_severityHasBeenSet;
+
+    bool m_enabled;
+    bool m_enabledHasBeenSet;
+
+    Aws::Vector<Tag> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/CreateEventSubscriptionResult.h

@@ -0,0 +1,76 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/model/EventSubscription.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  class AWS_REDSHIFT_API CreateEventSubscriptionResult
+  {
+  public:
+    CreateEventSubscriptionResult();
+    CreateEventSubscriptionResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    CreateEventSubscriptionResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    
+    inline const EventSubscription& GetEventSubscription() const{ return m_eventSubscription; }
+
+    
+    inline void SetEventSubscription(const EventSubscription& value) { m_eventSubscription = value; }
+
+    
+    inline void SetEventSubscription(EventSubscription&& value) { m_eventSubscription = std::move(value); }
+
+    
+    inline CreateEventSubscriptionResult& WithEventSubscription(const EventSubscription& value) { SetEventSubscription(value); return *this;}
+
+    
+    inline CreateEventSubscriptionResult& WithEventSubscription(EventSubscription&& value) { SetEventSubscription(std::move(value)); return *this;}
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline CreateEventSubscriptionResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline CreateEventSubscriptionResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    EventSubscription m_eventSubscription;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/CreateHsmClientCertificateRequest.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/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p/><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/CreateHsmClientCertificateMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API CreateHsmClientCertificateRequest : public RedshiftRequest
+  {
+  public:
+    CreateHsmClientCertificateRequest();
+
+    // 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 "CreateHsmClientCertificate"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The identifier to be assigned to the new HSM client certificate that the
+     * cluster will use to connect to the HSM to use the database encryption keys.</p>
+     */
+    inline const Aws::String& GetHsmClientCertificateIdentifier() const{ return m_hsmClientCertificateIdentifier; }
+
+    /**
+     * <p>The identifier to be assigned to the new HSM client certificate that the
+     * cluster will use to connect to the HSM to use the database encryption keys.</p>
+     */
+    inline bool HsmClientCertificateIdentifierHasBeenSet() const { return m_hsmClientCertificateIdentifierHasBeenSet; }
+
+    /**
+     * <p>The identifier to be assigned to the new HSM client certificate that the
+     * cluster will use to connect to the HSM to use the database encryption keys.</p>
+     */
+    inline void SetHsmClientCertificateIdentifier(const Aws::String& value) { m_hsmClientCertificateIdentifierHasBeenSet = true; m_hsmClientCertificateIdentifier = value; }
+
+    /**
+     * <p>The identifier to be assigned to the new HSM client certificate that the
+     * cluster will use to connect to the HSM to use the database encryption keys.</p>
+     */
+    inline void SetHsmClientCertificateIdentifier(Aws::String&& value) { m_hsmClientCertificateIdentifierHasBeenSet = true; m_hsmClientCertificateIdentifier = std::move(value); }
+
+    /**
+     * <p>The identifier to be assigned to the new HSM client certificate that the
+     * cluster will use to connect to the HSM to use the database encryption keys.</p>
+     */
+    inline void SetHsmClientCertificateIdentifier(const char* value) { m_hsmClientCertificateIdentifierHasBeenSet = true; m_hsmClientCertificateIdentifier.assign(value); }
+
+    /**
+     * <p>The identifier to be assigned to the new HSM client certificate that the
+     * cluster will use to connect to the HSM to use the database encryption keys.</p>
+     */
+    inline CreateHsmClientCertificateRequest& WithHsmClientCertificateIdentifier(const Aws::String& value) { SetHsmClientCertificateIdentifier(value); return *this;}
+
+    /**
+     * <p>The identifier to be assigned to the new HSM client certificate that the
+     * cluster will use to connect to the HSM to use the database encryption keys.</p>
+     */
+    inline CreateHsmClientCertificateRequest& WithHsmClientCertificateIdentifier(Aws::String&& value) { SetHsmClientCertificateIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>The identifier to be assigned to the new HSM client certificate that the
+     * cluster will use to connect to the HSM to use the database encryption keys.</p>
+     */
+    inline CreateHsmClientCertificateRequest& WithHsmClientCertificateIdentifier(const char* value) { SetHsmClientCertificateIdentifier(value); return *this;}
+
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateHsmClientCertificateRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateHsmClientCertificateRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateHsmClientCertificateRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateHsmClientCertificateRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_hsmClientCertificateIdentifier;
+    bool m_hsmClientCertificateIdentifierHasBeenSet;
+
+    Aws::Vector<Tag> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/CreateHsmClientCertificateResult.h

@@ -0,0 +1,76 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/model/HsmClientCertificate.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  class AWS_REDSHIFT_API CreateHsmClientCertificateResult
+  {
+  public:
+    CreateHsmClientCertificateResult();
+    CreateHsmClientCertificateResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    CreateHsmClientCertificateResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    
+    inline const HsmClientCertificate& GetHsmClientCertificate() const{ return m_hsmClientCertificate; }
+
+    
+    inline void SetHsmClientCertificate(const HsmClientCertificate& value) { m_hsmClientCertificate = value; }
+
+    
+    inline void SetHsmClientCertificate(HsmClientCertificate&& value) { m_hsmClientCertificate = std::move(value); }
+
+    
+    inline CreateHsmClientCertificateResult& WithHsmClientCertificate(const HsmClientCertificate& value) { SetHsmClientCertificate(value); return *this;}
+
+    
+    inline CreateHsmClientCertificateResult& WithHsmClientCertificate(HsmClientCertificate&& value) { SetHsmClientCertificate(std::move(value)); return *this;}
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline CreateHsmClientCertificateResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline CreateHsmClientCertificateResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    HsmClientCertificate m_hsmClientCertificate;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/CreateHsmConfigurationRequest.h

@@ -0,0 +1,388 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p/><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/CreateHsmConfigurationMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API CreateHsmConfigurationRequest : public RedshiftRequest
+  {
+  public:
+    CreateHsmConfigurationRequest();
+
+    // 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 "CreateHsmConfiguration"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The identifier to be assigned to the new Amazon Redshift HSM
+     * configuration.</p>
+     */
+    inline const Aws::String& GetHsmConfigurationIdentifier() const{ return m_hsmConfigurationIdentifier; }
+
+    /**
+     * <p>The identifier to be assigned to the new Amazon Redshift HSM
+     * configuration.</p>
+     */
+    inline bool HsmConfigurationIdentifierHasBeenSet() const { return m_hsmConfigurationIdentifierHasBeenSet; }
+
+    /**
+     * <p>The identifier to be assigned to the new Amazon Redshift HSM
+     * configuration.</p>
+     */
+    inline void SetHsmConfigurationIdentifier(const Aws::String& value) { m_hsmConfigurationIdentifierHasBeenSet = true; m_hsmConfigurationIdentifier = value; }
+
+    /**
+     * <p>The identifier to be assigned to the new Amazon Redshift HSM
+     * configuration.</p>
+     */
+    inline void SetHsmConfigurationIdentifier(Aws::String&& value) { m_hsmConfigurationIdentifierHasBeenSet = true; m_hsmConfigurationIdentifier = std::move(value); }
+
+    /**
+     * <p>The identifier to be assigned to the new Amazon Redshift HSM
+     * configuration.</p>
+     */
+    inline void SetHsmConfigurationIdentifier(const char* value) { m_hsmConfigurationIdentifierHasBeenSet = true; m_hsmConfigurationIdentifier.assign(value); }
+
+    /**
+     * <p>The identifier to be assigned to the new Amazon Redshift HSM
+     * configuration.</p>
+     */
+    inline CreateHsmConfigurationRequest& WithHsmConfigurationIdentifier(const Aws::String& value) { SetHsmConfigurationIdentifier(value); return *this;}
+
+    /**
+     * <p>The identifier to be assigned to the new Amazon Redshift HSM
+     * configuration.</p>
+     */
+    inline CreateHsmConfigurationRequest& WithHsmConfigurationIdentifier(Aws::String&& value) { SetHsmConfigurationIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>The identifier to be assigned to the new Amazon Redshift HSM
+     * configuration.</p>
+     */
+    inline CreateHsmConfigurationRequest& WithHsmConfigurationIdentifier(const char* value) { SetHsmConfigurationIdentifier(value); return *this;}
+
+
+    /**
+     * <p>A text description of the HSM configuration to be created.</p>
+     */
+    inline const Aws::String& GetDescription() const{ return m_description; }
+
+    /**
+     * <p>A text description of the HSM configuration to be created.</p>
+     */
+    inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
+
+    /**
+     * <p>A text description of the HSM configuration to be created.</p>
+     */
+    inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
+
+    /**
+     * <p>A text description of the HSM configuration to be created.</p>
+     */
+    inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
+
+    /**
+     * <p>A text description of the HSM configuration to be created.</p>
+     */
+    inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
+
+    /**
+     * <p>A text description of the HSM configuration to be created.</p>
+     */
+    inline CreateHsmConfigurationRequest& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
+
+    /**
+     * <p>A text description of the HSM configuration to be created.</p>
+     */
+    inline CreateHsmConfigurationRequest& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
+
+    /**
+     * <p>A text description of the HSM configuration to be created.</p>
+     */
+    inline CreateHsmConfigurationRequest& WithDescription(const char* value) { SetDescription(value); return *this;}
+
+
+    /**
+     * <p>The IP address that the Amazon Redshift cluster must use to access the
+     * HSM.</p>
+     */
+    inline const Aws::String& GetHsmIpAddress() const{ return m_hsmIpAddress; }
+
+    /**
+     * <p>The IP address that the Amazon Redshift cluster must use to access the
+     * HSM.</p>
+     */
+    inline bool HsmIpAddressHasBeenSet() const { return m_hsmIpAddressHasBeenSet; }
+
+    /**
+     * <p>The IP address that the Amazon Redshift cluster must use to access the
+     * HSM.</p>
+     */
+    inline void SetHsmIpAddress(const Aws::String& value) { m_hsmIpAddressHasBeenSet = true; m_hsmIpAddress = value; }
+
+    /**
+     * <p>The IP address that the Amazon Redshift cluster must use to access the
+     * HSM.</p>
+     */
+    inline void SetHsmIpAddress(Aws::String&& value) { m_hsmIpAddressHasBeenSet = true; m_hsmIpAddress = std::move(value); }
+
+    /**
+     * <p>The IP address that the Amazon Redshift cluster must use to access the
+     * HSM.</p>
+     */
+    inline void SetHsmIpAddress(const char* value) { m_hsmIpAddressHasBeenSet = true; m_hsmIpAddress.assign(value); }
+
+    /**
+     * <p>The IP address that the Amazon Redshift cluster must use to access the
+     * HSM.</p>
+     */
+    inline CreateHsmConfigurationRequest& WithHsmIpAddress(const Aws::String& value) { SetHsmIpAddress(value); return *this;}
+
+    /**
+     * <p>The IP address that the Amazon Redshift cluster must use to access the
+     * HSM.</p>
+     */
+    inline CreateHsmConfigurationRequest& WithHsmIpAddress(Aws::String&& value) { SetHsmIpAddress(std::move(value)); return *this;}
+
+    /**
+     * <p>The IP address that the Amazon Redshift cluster must use to access the
+     * HSM.</p>
+     */
+    inline CreateHsmConfigurationRequest& WithHsmIpAddress(const char* value) { SetHsmIpAddress(value); return *this;}
+
+
+    /**
+     * <p>The name of the partition in the HSM where the Amazon Redshift clusters will
+     * store their database encryption keys.</p>
+     */
+    inline const Aws::String& GetHsmPartitionName() const{ return m_hsmPartitionName; }
+
+    /**
+     * <p>The name of the partition in the HSM where the Amazon Redshift clusters will
+     * store their database encryption keys.</p>
+     */
+    inline bool HsmPartitionNameHasBeenSet() const { return m_hsmPartitionNameHasBeenSet; }
+
+    /**
+     * <p>The name of the partition in the HSM where the Amazon Redshift clusters will
+     * store their database encryption keys.</p>
+     */
+    inline void SetHsmPartitionName(const Aws::String& value) { m_hsmPartitionNameHasBeenSet = true; m_hsmPartitionName = value; }
+
+    /**
+     * <p>The name of the partition in the HSM where the Amazon Redshift clusters will
+     * store their database encryption keys.</p>
+     */
+    inline void SetHsmPartitionName(Aws::String&& value) { m_hsmPartitionNameHasBeenSet = true; m_hsmPartitionName = std::move(value); }
+
+    /**
+     * <p>The name of the partition in the HSM where the Amazon Redshift clusters will
+     * store their database encryption keys.</p>
+     */
+    inline void SetHsmPartitionName(const char* value) { m_hsmPartitionNameHasBeenSet = true; m_hsmPartitionName.assign(value); }
+
+    /**
+     * <p>The name of the partition in the HSM where the Amazon Redshift clusters will
+     * store their database encryption keys.</p>
+     */
+    inline CreateHsmConfigurationRequest& WithHsmPartitionName(const Aws::String& value) { SetHsmPartitionName(value); return *this;}
+
+    /**
+     * <p>The name of the partition in the HSM where the Amazon Redshift clusters will
+     * store their database encryption keys.</p>
+     */
+    inline CreateHsmConfigurationRequest& WithHsmPartitionName(Aws::String&& value) { SetHsmPartitionName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the partition in the HSM where the Amazon Redshift clusters will
+     * store their database encryption keys.</p>
+     */
+    inline CreateHsmConfigurationRequest& WithHsmPartitionName(const char* value) { SetHsmPartitionName(value); return *this;}
+
+
+    /**
+     * <p>The password required to access the HSM partition.</p>
+     */
+    inline const Aws::String& GetHsmPartitionPassword() const{ return m_hsmPartitionPassword; }
+
+    /**
+     * <p>The password required to access the HSM partition.</p>
+     */
+    inline bool HsmPartitionPasswordHasBeenSet() const { return m_hsmPartitionPasswordHasBeenSet; }
+
+    /**
+     * <p>The password required to access the HSM partition.</p>
+     */
+    inline void SetHsmPartitionPassword(const Aws::String& value) { m_hsmPartitionPasswordHasBeenSet = true; m_hsmPartitionPassword = value; }
+
+    /**
+     * <p>The password required to access the HSM partition.</p>
+     */
+    inline void SetHsmPartitionPassword(Aws::String&& value) { m_hsmPartitionPasswordHasBeenSet = true; m_hsmPartitionPassword = std::move(value); }
+
+    /**
+     * <p>The password required to access the HSM partition.</p>
+     */
+    inline void SetHsmPartitionPassword(const char* value) { m_hsmPartitionPasswordHasBeenSet = true; m_hsmPartitionPassword.assign(value); }
+
+    /**
+     * <p>The password required to access the HSM partition.</p>
+     */
+    inline CreateHsmConfigurationRequest& WithHsmPartitionPassword(const Aws::String& value) { SetHsmPartitionPassword(value); return *this;}
+
+    /**
+     * <p>The password required to access the HSM partition.</p>
+     */
+    inline CreateHsmConfigurationRequest& WithHsmPartitionPassword(Aws::String&& value) { SetHsmPartitionPassword(std::move(value)); return *this;}
+
+    /**
+     * <p>The password required to access the HSM partition.</p>
+     */
+    inline CreateHsmConfigurationRequest& WithHsmPartitionPassword(const char* value) { SetHsmPartitionPassword(value); return *this;}
+
+
+    /**
+     * <p>The HSMs public certificate file. When using Cloud HSM, the file name is
+     * server.pem.</p>
+     */
+    inline const Aws::String& GetHsmServerPublicCertificate() const{ return m_hsmServerPublicCertificate; }
+
+    /**
+     * <p>The HSMs public certificate file. When using Cloud HSM, the file name is
+     * server.pem.</p>
+     */
+    inline bool HsmServerPublicCertificateHasBeenSet() const { return m_hsmServerPublicCertificateHasBeenSet; }
+
+    /**
+     * <p>The HSMs public certificate file. When using Cloud HSM, the file name is
+     * server.pem.</p>
+     */
+    inline void SetHsmServerPublicCertificate(const Aws::String& value) { m_hsmServerPublicCertificateHasBeenSet = true; m_hsmServerPublicCertificate = value; }
+
+    /**
+     * <p>The HSMs public certificate file. When using Cloud HSM, the file name is
+     * server.pem.</p>
+     */
+    inline void SetHsmServerPublicCertificate(Aws::String&& value) { m_hsmServerPublicCertificateHasBeenSet = true; m_hsmServerPublicCertificate = std::move(value); }
+
+    /**
+     * <p>The HSMs public certificate file. When using Cloud HSM, the file name is
+     * server.pem.</p>
+     */
+    inline void SetHsmServerPublicCertificate(const char* value) { m_hsmServerPublicCertificateHasBeenSet = true; m_hsmServerPublicCertificate.assign(value); }
+
+    /**
+     * <p>The HSMs public certificate file. When using Cloud HSM, the file name is
+     * server.pem.</p>
+     */
+    inline CreateHsmConfigurationRequest& WithHsmServerPublicCertificate(const Aws::String& value) { SetHsmServerPublicCertificate(value); return *this;}
+
+    /**
+     * <p>The HSMs public certificate file. When using Cloud HSM, the file name is
+     * server.pem.</p>
+     */
+    inline CreateHsmConfigurationRequest& WithHsmServerPublicCertificate(Aws::String&& value) { SetHsmServerPublicCertificate(std::move(value)); return *this;}
+
+    /**
+     * <p>The HSMs public certificate file. When using Cloud HSM, the file name is
+     * server.pem.</p>
+     */
+    inline CreateHsmConfigurationRequest& WithHsmServerPublicCertificate(const char* value) { SetHsmServerPublicCertificate(value); return *this;}
+
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateHsmConfigurationRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateHsmConfigurationRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateHsmConfigurationRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateHsmConfigurationRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_hsmConfigurationIdentifier;
+    bool m_hsmConfigurationIdentifierHasBeenSet;
+
+    Aws::String m_description;
+    bool m_descriptionHasBeenSet;
+
+    Aws::String m_hsmIpAddress;
+    bool m_hsmIpAddressHasBeenSet;
+
+    Aws::String m_hsmPartitionName;
+    bool m_hsmPartitionNameHasBeenSet;
+
+    Aws::String m_hsmPartitionPassword;
+    bool m_hsmPartitionPasswordHasBeenSet;
+
+    Aws::String m_hsmServerPublicCertificate;
+    bool m_hsmServerPublicCertificateHasBeenSet;
+
+    Aws::Vector<Tag> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/CreateHsmConfigurationResult.h

@@ -0,0 +1,76 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/model/HsmConfiguration.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  class AWS_REDSHIFT_API CreateHsmConfigurationResult
+  {
+  public:
+    CreateHsmConfigurationResult();
+    CreateHsmConfigurationResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    CreateHsmConfigurationResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    
+    inline const HsmConfiguration& GetHsmConfiguration() const{ return m_hsmConfiguration; }
+
+    
+    inline void SetHsmConfiguration(const HsmConfiguration& value) { m_hsmConfiguration = value; }
+
+    
+    inline void SetHsmConfiguration(HsmConfiguration&& value) { m_hsmConfiguration = std::move(value); }
+
+    
+    inline CreateHsmConfigurationResult& WithHsmConfiguration(const HsmConfiguration& value) { SetHsmConfiguration(value); return *this;}
+
+    
+    inline CreateHsmConfigurationResult& WithHsmConfiguration(HsmConfiguration&& value) { SetHsmConfiguration(std::move(value)); return *this;}
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline CreateHsmConfigurationResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline CreateHsmConfigurationResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    HsmConfiguration m_hsmConfiguration;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/CreateScheduledActionRequest.h

@@ -0,0 +1,415 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/redshift/model/ScheduledActionType.h>
+#include <aws/core/utils/DateTime.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_REDSHIFT_API CreateScheduledActionRequest : public RedshiftRequest
+  {
+  public:
+    CreateScheduledActionRequest();
+
+    // 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 "CreateScheduledAction"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The name of the scheduled action. The name must be unique within an account.
+     * For more information about this parameter, see <a>ScheduledAction</a>. </p>
+     */
+    inline const Aws::String& GetScheduledActionName() const{ return m_scheduledActionName; }
+
+    /**
+     * <p>The name of the scheduled action. The name must be unique within an account.
+     * For more information about this parameter, see <a>ScheduledAction</a>. </p>
+     */
+    inline bool ScheduledActionNameHasBeenSet() const { return m_scheduledActionNameHasBeenSet; }
+
+    /**
+     * <p>The name of the scheduled action. The name must be unique within an account.
+     * For more information about this parameter, see <a>ScheduledAction</a>. </p>
+     */
+    inline void SetScheduledActionName(const Aws::String& value) { m_scheduledActionNameHasBeenSet = true; m_scheduledActionName = value; }
+
+    /**
+     * <p>The name of the scheduled action. The name must be unique within an account.
+     * For more information about this parameter, see <a>ScheduledAction</a>. </p>
+     */
+    inline void SetScheduledActionName(Aws::String&& value) { m_scheduledActionNameHasBeenSet = true; m_scheduledActionName = std::move(value); }
+
+    /**
+     * <p>The name of the scheduled action. The name must be unique within an account.
+     * For more information about this parameter, see <a>ScheduledAction</a>. </p>
+     */
+    inline void SetScheduledActionName(const char* value) { m_scheduledActionNameHasBeenSet = true; m_scheduledActionName.assign(value); }
+
+    /**
+     * <p>The name of the scheduled action. The name must be unique within an account.
+     * For more information about this parameter, see <a>ScheduledAction</a>. </p>
+     */
+    inline CreateScheduledActionRequest& WithScheduledActionName(const Aws::String& value) { SetScheduledActionName(value); return *this;}
+
+    /**
+     * <p>The name of the scheduled action. The name must be unique within an account.
+     * For more information about this parameter, see <a>ScheduledAction</a>. </p>
+     */
+    inline CreateScheduledActionRequest& WithScheduledActionName(Aws::String&& value) { SetScheduledActionName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the scheduled action. The name must be unique within an account.
+     * For more information about this parameter, see <a>ScheduledAction</a>. </p>
+     */
+    inline CreateScheduledActionRequest& WithScheduledActionName(const char* value) { SetScheduledActionName(value); return *this;}
+
+
+    /**
+     * <p>A JSON format string of the Amazon Redshift API operation with input
+     * parameters. For more information about this parameter, see
+     * <a>ScheduledAction</a>. </p>
+     */
+    inline const ScheduledActionType& GetTargetAction() const{ return m_targetAction; }
+
+    /**
+     * <p>A JSON format string of the Amazon Redshift API operation with input
+     * parameters. For more information about this parameter, see
+     * <a>ScheduledAction</a>. </p>
+     */
+    inline bool TargetActionHasBeenSet() const { return m_targetActionHasBeenSet; }
+
+    /**
+     * <p>A JSON format string of the Amazon Redshift API operation with input
+     * parameters. For more information about this parameter, see
+     * <a>ScheduledAction</a>. </p>
+     */
+    inline void SetTargetAction(const ScheduledActionType& value) { m_targetActionHasBeenSet = true; m_targetAction = value; }
+
+    /**
+     * <p>A JSON format string of the Amazon Redshift API operation with input
+     * parameters. For more information about this parameter, see
+     * <a>ScheduledAction</a>. </p>
+     */
+    inline void SetTargetAction(ScheduledActionType&& value) { m_targetActionHasBeenSet = true; m_targetAction = std::move(value); }
+
+    /**
+     * <p>A JSON format string of the Amazon Redshift API operation with input
+     * parameters. For more information about this parameter, see
+     * <a>ScheduledAction</a>. </p>
+     */
+    inline CreateScheduledActionRequest& WithTargetAction(const ScheduledActionType& value) { SetTargetAction(value); return *this;}
+
+    /**
+     * <p>A JSON format string of the Amazon Redshift API operation with input
+     * parameters. For more information about this parameter, see
+     * <a>ScheduledAction</a>. </p>
+     */
+    inline CreateScheduledActionRequest& WithTargetAction(ScheduledActionType&& value) { SetTargetAction(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The schedule in <code>at( )</code> or <code>cron( )</code> format. For more
+     * information about this parameter, see <a>ScheduledAction</a>.</p>
+     */
+    inline const Aws::String& GetSchedule() const{ return m_schedule; }
+
+    /**
+     * <p>The schedule in <code>at( )</code> or <code>cron( )</code> format. For more
+     * information about this parameter, see <a>ScheduledAction</a>.</p>
+     */
+    inline bool ScheduleHasBeenSet() const { return m_scheduleHasBeenSet; }
+
+    /**
+     * <p>The schedule in <code>at( )</code> or <code>cron( )</code> format. For more
+     * information about this parameter, see <a>ScheduledAction</a>.</p>
+     */
+    inline void SetSchedule(const Aws::String& value) { m_scheduleHasBeenSet = true; m_schedule = value; }
+
+    /**
+     * <p>The schedule in <code>at( )</code> or <code>cron( )</code> format. For more
+     * information about this parameter, see <a>ScheduledAction</a>.</p>
+     */
+    inline void SetSchedule(Aws::String&& value) { m_scheduleHasBeenSet = true; m_schedule = std::move(value); }
+
+    /**
+     * <p>The schedule in <code>at( )</code> or <code>cron( )</code> format. For more
+     * information about this parameter, see <a>ScheduledAction</a>.</p>
+     */
+    inline void SetSchedule(const char* value) { m_scheduleHasBeenSet = true; m_schedule.assign(value); }
+
+    /**
+     * <p>The schedule in <code>at( )</code> or <code>cron( )</code> format. For more
+     * information about this parameter, see <a>ScheduledAction</a>.</p>
+     */
+    inline CreateScheduledActionRequest& WithSchedule(const Aws::String& value) { SetSchedule(value); return *this;}
+
+    /**
+     * <p>The schedule in <code>at( )</code> or <code>cron( )</code> format. For more
+     * information about this parameter, see <a>ScheduledAction</a>.</p>
+     */
+    inline CreateScheduledActionRequest& WithSchedule(Aws::String&& value) { SetSchedule(std::move(value)); return *this;}
+
+    /**
+     * <p>The schedule in <code>at( )</code> or <code>cron( )</code> format. For more
+     * information about this parameter, see <a>ScheduledAction</a>.</p>
+     */
+    inline CreateScheduledActionRequest& WithSchedule(const char* value) { SetSchedule(value); return *this;}
+
+
+    /**
+     * <p>The IAM role to assume to run the target action. For more information about
+     * this parameter, see <a>ScheduledAction</a>. </p>
+     */
+    inline const Aws::String& GetIamRole() const{ return m_iamRole; }
+
+    /**
+     * <p>The IAM role to assume to run the target action. For more information about
+     * this parameter, see <a>ScheduledAction</a>. </p>
+     */
+    inline bool IamRoleHasBeenSet() const { return m_iamRoleHasBeenSet; }
+
+    /**
+     * <p>The IAM role to assume to run the target action. For more information about
+     * this parameter, see <a>ScheduledAction</a>. </p>
+     */
+    inline void SetIamRole(const Aws::String& value) { m_iamRoleHasBeenSet = true; m_iamRole = value; }
+
+    /**
+     * <p>The IAM role to assume to run the target action. For more information about
+     * this parameter, see <a>ScheduledAction</a>. </p>
+     */
+    inline void SetIamRole(Aws::String&& value) { m_iamRoleHasBeenSet = true; m_iamRole = std::move(value); }
+
+    /**
+     * <p>The IAM role to assume to run the target action. For more information about
+     * this parameter, see <a>ScheduledAction</a>. </p>
+     */
+    inline void SetIamRole(const char* value) { m_iamRoleHasBeenSet = true; m_iamRole.assign(value); }
+
+    /**
+     * <p>The IAM role to assume to run the target action. For more information about
+     * this parameter, see <a>ScheduledAction</a>. </p>
+     */
+    inline CreateScheduledActionRequest& WithIamRole(const Aws::String& value) { SetIamRole(value); return *this;}
+
+    /**
+     * <p>The IAM role to assume to run the target action. For more information about
+     * this parameter, see <a>ScheduledAction</a>. </p>
+     */
+    inline CreateScheduledActionRequest& WithIamRole(Aws::String&& value) { SetIamRole(std::move(value)); return *this;}
+
+    /**
+     * <p>The IAM role to assume to run the target action. For more information about
+     * this parameter, see <a>ScheduledAction</a>. </p>
+     */
+    inline CreateScheduledActionRequest& WithIamRole(const char* value) { SetIamRole(value); return *this;}
+
+
+    /**
+     * <p>The description of the scheduled action. </p>
+     */
+    inline const Aws::String& GetScheduledActionDescription() const{ return m_scheduledActionDescription; }
+
+    /**
+     * <p>The description of the scheduled action. </p>
+     */
+    inline bool ScheduledActionDescriptionHasBeenSet() const { return m_scheduledActionDescriptionHasBeenSet; }
+
+    /**
+     * <p>The description of the scheduled action. </p>
+     */
+    inline void SetScheduledActionDescription(const Aws::String& value) { m_scheduledActionDescriptionHasBeenSet = true; m_scheduledActionDescription = value; }
+
+    /**
+     * <p>The description of the scheduled action. </p>
+     */
+    inline void SetScheduledActionDescription(Aws::String&& value) { m_scheduledActionDescriptionHasBeenSet = true; m_scheduledActionDescription = std::move(value); }
+
+    /**
+     * <p>The description of the scheduled action. </p>
+     */
+    inline void SetScheduledActionDescription(const char* value) { m_scheduledActionDescriptionHasBeenSet = true; m_scheduledActionDescription.assign(value); }
+
+    /**
+     * <p>The description of the scheduled action. </p>
+     */
+    inline CreateScheduledActionRequest& WithScheduledActionDescription(const Aws::String& value) { SetScheduledActionDescription(value); return *this;}
+
+    /**
+     * <p>The description of the scheduled action. </p>
+     */
+    inline CreateScheduledActionRequest& WithScheduledActionDescription(Aws::String&& value) { SetScheduledActionDescription(std::move(value)); return *this;}
+
+    /**
+     * <p>The description of the scheduled action. </p>
+     */
+    inline CreateScheduledActionRequest& WithScheduledActionDescription(const char* value) { SetScheduledActionDescription(value); return *this;}
+
+
+    /**
+     * <p>The start time in UTC of the scheduled action. Before this time, the
+     * scheduled action does not trigger. For more information about this parameter,
+     * see <a>ScheduledAction</a>.</p>
+     */
+    inline const Aws::Utils::DateTime& GetStartTime() const{ return m_startTime; }
+
+    /**
+     * <p>The start time in UTC of the scheduled action. Before this time, the
+     * scheduled action does not trigger. For more information about this parameter,
+     * see <a>ScheduledAction</a>.</p>
+     */
+    inline bool StartTimeHasBeenSet() const { return m_startTimeHasBeenSet; }
+
+    /**
+     * <p>The start time in UTC of the scheduled action. Before this time, the
+     * scheduled action does not trigger. For more information about this parameter,
+     * see <a>ScheduledAction</a>.</p>
+     */
+    inline void SetStartTime(const Aws::Utils::DateTime& value) { m_startTimeHasBeenSet = true; m_startTime = value; }
+
+    /**
+     * <p>The start time in UTC of the scheduled action. Before this time, the
+     * scheduled action does not trigger. For more information about this parameter,
+     * see <a>ScheduledAction</a>.</p>
+     */
+    inline void SetStartTime(Aws::Utils::DateTime&& value) { m_startTimeHasBeenSet = true; m_startTime = std::move(value); }
+
+    /**
+     * <p>The start time in UTC of the scheduled action. Before this time, the
+     * scheduled action does not trigger. For more information about this parameter,
+     * see <a>ScheduledAction</a>.</p>
+     */
+    inline CreateScheduledActionRequest& WithStartTime(const Aws::Utils::DateTime& value) { SetStartTime(value); return *this;}
+
+    /**
+     * <p>The start time in UTC of the scheduled action. Before this time, the
+     * scheduled action does not trigger. For more information about this parameter,
+     * see <a>ScheduledAction</a>.</p>
+     */
+    inline CreateScheduledActionRequest& WithStartTime(Aws::Utils::DateTime&& value) { SetStartTime(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The end time in UTC of the scheduled action. After this time, the scheduled
+     * action does not trigger. For more information about this parameter, see
+     * <a>ScheduledAction</a>. </p>
+     */
+    inline const Aws::Utils::DateTime& GetEndTime() const{ return m_endTime; }
+
+    /**
+     * <p>The end time in UTC of the scheduled action. After this time, the scheduled
+     * action does not trigger. For more information about this parameter, see
+     * <a>ScheduledAction</a>. </p>
+     */
+    inline bool EndTimeHasBeenSet() const { return m_endTimeHasBeenSet; }
+
+    /**
+     * <p>The end time in UTC of the scheduled action. After this time, the scheduled
+     * action does not trigger. For more information about this parameter, see
+     * <a>ScheduledAction</a>. </p>
+     */
+    inline void SetEndTime(const Aws::Utils::DateTime& value) { m_endTimeHasBeenSet = true; m_endTime = value; }
+
+    /**
+     * <p>The end time in UTC of the scheduled action. After this time, the scheduled
+     * action does not trigger. For more information about this parameter, see
+     * <a>ScheduledAction</a>. </p>
+     */
+    inline void SetEndTime(Aws::Utils::DateTime&& value) { m_endTimeHasBeenSet = true; m_endTime = std::move(value); }
+
+    /**
+     * <p>The end time in UTC of the scheduled action. After this time, the scheduled
+     * action does not trigger. For more information about this parameter, see
+     * <a>ScheduledAction</a>. </p>
+     */
+    inline CreateScheduledActionRequest& WithEndTime(const Aws::Utils::DateTime& value) { SetEndTime(value); return *this;}
+
+    /**
+     * <p>The end time in UTC of the scheduled action. After this time, the scheduled
+     * action does not trigger. For more information about this parameter, see
+     * <a>ScheduledAction</a>. </p>
+     */
+    inline CreateScheduledActionRequest& WithEndTime(Aws::Utils::DateTime&& value) { SetEndTime(std::move(value)); return *this;}
+
+
+    /**
+     * <p>If true, the schedule is enabled. If false, the scheduled action does not
+     * trigger. For more information about <code>state</code> of the scheduled action,
+     * see <a>ScheduledAction</a>. </p>
+     */
+    inline bool GetEnable() const{ return m_enable; }
+
+    /**
+     * <p>If true, the schedule is enabled. If false, the scheduled action does not
+     * trigger. For more information about <code>state</code> of the scheduled action,
+     * see <a>ScheduledAction</a>. </p>
+     */
+    inline bool EnableHasBeenSet() const { return m_enableHasBeenSet; }
+
+    /**
+     * <p>If true, the schedule is enabled. If false, the scheduled action does not
+     * trigger. For more information about <code>state</code> of the scheduled action,
+     * see <a>ScheduledAction</a>. </p>
+     */
+    inline void SetEnable(bool value) { m_enableHasBeenSet = true; m_enable = value; }
+
+    /**
+     * <p>If true, the schedule is enabled. If false, the scheduled action does not
+     * trigger. For more information about <code>state</code> of the scheduled action,
+     * see <a>ScheduledAction</a>. </p>
+     */
+    inline CreateScheduledActionRequest& WithEnable(bool value) { SetEnable(value); return *this;}
+
+  private:
+
+    Aws::String m_scheduledActionName;
+    bool m_scheduledActionNameHasBeenSet;
+
+    ScheduledActionType m_targetAction;
+    bool m_targetActionHasBeenSet;
+
+    Aws::String m_schedule;
+    bool m_scheduleHasBeenSet;
+
+    Aws::String m_iamRole;
+    bool m_iamRoleHasBeenSet;
+
+    Aws::String m_scheduledActionDescription;
+    bool m_scheduledActionDescriptionHasBeenSet;
+
+    Aws::Utils::DateTime m_startTime;
+    bool m_startTimeHasBeenSet;
+
+    Aws::Utils::DateTime m_endTime;
+    bool m_endTimeHasBeenSet;
+
+    bool m_enable;
+    bool m_enableHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/CreateScheduledActionResult.h

@@ -0,0 +1,502 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/redshift/model/ScheduledActionType.h>
+#include <aws/redshift/model/ScheduledActionState.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/DateTime.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  /**
+   * <p>Describes a scheduled action. You can use a scheduled action to trigger some
+   * Amazon Redshift API operations on a schedule. For information about which API
+   * operations can be scheduled, see <a>ScheduledActionType</a>. </p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/ScheduledAction">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API CreateScheduledActionResult
+  {
+  public:
+    CreateScheduledActionResult();
+    CreateScheduledActionResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    CreateScheduledActionResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    /**
+     * <p>The name of the scheduled action. </p>
+     */
+    inline const Aws::String& GetScheduledActionName() const{ return m_scheduledActionName; }
+
+    /**
+     * <p>The name of the scheduled action. </p>
+     */
+    inline void SetScheduledActionName(const Aws::String& value) { m_scheduledActionName = value; }
+
+    /**
+     * <p>The name of the scheduled action. </p>
+     */
+    inline void SetScheduledActionName(Aws::String&& value) { m_scheduledActionName = std::move(value); }
+
+    /**
+     * <p>The name of the scheduled action. </p>
+     */
+    inline void SetScheduledActionName(const char* value) { m_scheduledActionName.assign(value); }
+
+    /**
+     * <p>The name of the scheduled action. </p>
+     */
+    inline CreateScheduledActionResult& WithScheduledActionName(const Aws::String& value) { SetScheduledActionName(value); return *this;}
+
+    /**
+     * <p>The name of the scheduled action. </p>
+     */
+    inline CreateScheduledActionResult& WithScheduledActionName(Aws::String&& value) { SetScheduledActionName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the scheduled action. </p>
+     */
+    inline CreateScheduledActionResult& WithScheduledActionName(const char* value) { SetScheduledActionName(value); return *this;}
+
+
+    /**
+     * <p>A JSON format string of the Amazon Redshift API operation with input
+     * parameters. </p>
+     * <p>"<code>{\"ResizeCluster\":{\"NodeType\":\"ds2.8xlarge\",\"ClusterIdentifier\":\"my-test-cluster\",\"NumberOfNodes\":3}}</code>".
+     * </p>
+     */
+    inline const ScheduledActionType& GetTargetAction() const{ return m_targetAction; }
+
+    /**
+     * <p>A JSON format string of the Amazon Redshift API operation with input
+     * parameters. </p>
+     * <p>"<code>{\"ResizeCluster\":{\"NodeType\":\"ds2.8xlarge\",\"ClusterIdentifier\":\"my-test-cluster\",\"NumberOfNodes\":3}}</code>".
+     * </p>
+     */
+    inline void SetTargetAction(const ScheduledActionType& value) { m_targetAction = value; }
+
+    /**
+     * <p>A JSON format string of the Amazon Redshift API operation with input
+     * parameters. </p>
+     * <p>"<code>{\"ResizeCluster\":{\"NodeType\":\"ds2.8xlarge\",\"ClusterIdentifier\":\"my-test-cluster\",\"NumberOfNodes\":3}}</code>".
+     * </p>
+     */
+    inline void SetTargetAction(ScheduledActionType&& value) { m_targetAction = std::move(value); }
+
+    /**
+     * <p>A JSON format string of the Amazon Redshift API operation with input
+     * parameters. </p>
+     * <p>"<code>{\"ResizeCluster\":{\"NodeType\":\"ds2.8xlarge\",\"ClusterIdentifier\":\"my-test-cluster\",\"NumberOfNodes\":3}}</code>".
+     * </p>
+     */
+    inline CreateScheduledActionResult& WithTargetAction(const ScheduledActionType& value) { SetTargetAction(value); return *this;}
+
+    /**
+     * <p>A JSON format string of the Amazon Redshift API operation with input
+     * parameters. </p>
+     * <p>"<code>{\"ResizeCluster\":{\"NodeType\":\"ds2.8xlarge\",\"ClusterIdentifier\":\"my-test-cluster\",\"NumberOfNodes\":3}}</code>".
+     * </p>
+     */
+    inline CreateScheduledActionResult& WithTargetAction(ScheduledActionType&& value) { SetTargetAction(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The schedule for a one-time (at format) or recurring (cron format) scheduled
+     * action. Schedule invocations must be separated by at least one hour.</p>
+     * <p>Format of at expressions is "<code>at(yyyy-mm-ddThh:mm:ss)</code>". For
+     * example, "<code>at(2016-03-04T17:27:00)</code>".</p> <p>Format of cron
+     * expressions is "<code>cron(Minutes Hours Day-of-month Month Day-of-week
+     * Year)</code>". For example, "<code>cron(0 10 ? * MON *)</code>". For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html#CronExpressions">Cron
+     * Expressions</a> in the <i>Amazon CloudWatch Events User Guide</i>.</p>
+     */
+    inline const Aws::String& GetSchedule() const{ return m_schedule; }
+
+    /**
+     * <p>The schedule for a one-time (at format) or recurring (cron format) scheduled
+     * action. Schedule invocations must be separated by at least one hour.</p>
+     * <p>Format of at expressions is "<code>at(yyyy-mm-ddThh:mm:ss)</code>". For
+     * example, "<code>at(2016-03-04T17:27:00)</code>".</p> <p>Format of cron
+     * expressions is "<code>cron(Minutes Hours Day-of-month Month Day-of-week
+     * Year)</code>". For example, "<code>cron(0 10 ? * MON *)</code>". For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html#CronExpressions">Cron
+     * Expressions</a> in the <i>Amazon CloudWatch Events User Guide</i>.</p>
+     */
+    inline void SetSchedule(const Aws::String& value) { m_schedule = value; }
+
+    /**
+     * <p>The schedule for a one-time (at format) or recurring (cron format) scheduled
+     * action. Schedule invocations must be separated by at least one hour.</p>
+     * <p>Format of at expressions is "<code>at(yyyy-mm-ddThh:mm:ss)</code>". For
+     * example, "<code>at(2016-03-04T17:27:00)</code>".</p> <p>Format of cron
+     * expressions is "<code>cron(Minutes Hours Day-of-month Month Day-of-week
+     * Year)</code>". For example, "<code>cron(0 10 ? * MON *)</code>". For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html#CronExpressions">Cron
+     * Expressions</a> in the <i>Amazon CloudWatch Events User Guide</i>.</p>
+     */
+    inline void SetSchedule(Aws::String&& value) { m_schedule = std::move(value); }
+
+    /**
+     * <p>The schedule for a one-time (at format) or recurring (cron format) scheduled
+     * action. Schedule invocations must be separated by at least one hour.</p>
+     * <p>Format of at expressions is "<code>at(yyyy-mm-ddThh:mm:ss)</code>". For
+     * example, "<code>at(2016-03-04T17:27:00)</code>".</p> <p>Format of cron
+     * expressions is "<code>cron(Minutes Hours Day-of-month Month Day-of-week
+     * Year)</code>". For example, "<code>cron(0 10 ? * MON *)</code>". For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html#CronExpressions">Cron
+     * Expressions</a> in the <i>Amazon CloudWatch Events User Guide</i>.</p>
+     */
+    inline void SetSchedule(const char* value) { m_schedule.assign(value); }
+
+    /**
+     * <p>The schedule for a one-time (at format) or recurring (cron format) scheduled
+     * action. Schedule invocations must be separated by at least one hour.</p>
+     * <p>Format of at expressions is "<code>at(yyyy-mm-ddThh:mm:ss)</code>". For
+     * example, "<code>at(2016-03-04T17:27:00)</code>".</p> <p>Format of cron
+     * expressions is "<code>cron(Minutes Hours Day-of-month Month Day-of-week
+     * Year)</code>". For example, "<code>cron(0 10 ? * MON *)</code>". For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html#CronExpressions">Cron
+     * Expressions</a> in the <i>Amazon CloudWatch Events User Guide</i>.</p>
+     */
+    inline CreateScheduledActionResult& WithSchedule(const Aws::String& value) { SetSchedule(value); return *this;}
+
+    /**
+     * <p>The schedule for a one-time (at format) or recurring (cron format) scheduled
+     * action. Schedule invocations must be separated by at least one hour.</p>
+     * <p>Format of at expressions is "<code>at(yyyy-mm-ddThh:mm:ss)</code>". For
+     * example, "<code>at(2016-03-04T17:27:00)</code>".</p> <p>Format of cron
+     * expressions is "<code>cron(Minutes Hours Day-of-month Month Day-of-week
+     * Year)</code>". For example, "<code>cron(0 10 ? * MON *)</code>". For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html#CronExpressions">Cron
+     * Expressions</a> in the <i>Amazon CloudWatch Events User Guide</i>.</p>
+     */
+    inline CreateScheduledActionResult& WithSchedule(Aws::String&& value) { SetSchedule(std::move(value)); return *this;}
+
+    /**
+     * <p>The schedule for a one-time (at format) or recurring (cron format) scheduled
+     * action. Schedule invocations must be separated by at least one hour.</p>
+     * <p>Format of at expressions is "<code>at(yyyy-mm-ddThh:mm:ss)</code>". For
+     * example, "<code>at(2016-03-04T17:27:00)</code>".</p> <p>Format of cron
+     * expressions is "<code>cron(Minutes Hours Day-of-month Month Day-of-week
+     * Year)</code>". For example, "<code>cron(0 10 ? * MON *)</code>". For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html#CronExpressions">Cron
+     * Expressions</a> in the <i>Amazon CloudWatch Events User Guide</i>.</p>
+     */
+    inline CreateScheduledActionResult& WithSchedule(const char* value) { SetSchedule(value); return *this;}
+
+
+    /**
+     * <p>The IAM role to assume to run the scheduled action. This IAM role must have
+     * permission to run the Amazon Redshift API operation in the scheduled action.
+     * This IAM role must allow the Amazon Redshift scheduler (Principal
+     * scheduler.redshift.amazonaws.com) to assume permissions on your behalf. For more
+     * information about the IAM role to use with the Amazon Redshift scheduler, see <a
+     * href="https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-identity-based.html">Using
+     * Identity-Based Policies for Amazon Redshift</a> in the <i>Amazon Redshift
+     * Cluster Management Guide</i>. </p>
+     */
+    inline const Aws::String& GetIamRole() const{ return m_iamRole; }
+
+    /**
+     * <p>The IAM role to assume to run the scheduled action. This IAM role must have
+     * permission to run the Amazon Redshift API operation in the scheduled action.
+     * This IAM role must allow the Amazon Redshift scheduler (Principal
+     * scheduler.redshift.amazonaws.com) to assume permissions on your behalf. For more
+     * information about the IAM role to use with the Amazon Redshift scheduler, see <a
+     * href="https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-identity-based.html">Using
+     * Identity-Based Policies for Amazon Redshift</a> in the <i>Amazon Redshift
+     * Cluster Management Guide</i>. </p>
+     */
+    inline void SetIamRole(const Aws::String& value) { m_iamRole = value; }
+
+    /**
+     * <p>The IAM role to assume to run the scheduled action. This IAM role must have
+     * permission to run the Amazon Redshift API operation in the scheduled action.
+     * This IAM role must allow the Amazon Redshift scheduler (Principal
+     * scheduler.redshift.amazonaws.com) to assume permissions on your behalf. For more
+     * information about the IAM role to use with the Amazon Redshift scheduler, see <a
+     * href="https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-identity-based.html">Using
+     * Identity-Based Policies for Amazon Redshift</a> in the <i>Amazon Redshift
+     * Cluster Management Guide</i>. </p>
+     */
+    inline void SetIamRole(Aws::String&& value) { m_iamRole = std::move(value); }
+
+    /**
+     * <p>The IAM role to assume to run the scheduled action. This IAM role must have
+     * permission to run the Amazon Redshift API operation in the scheduled action.
+     * This IAM role must allow the Amazon Redshift scheduler (Principal
+     * scheduler.redshift.amazonaws.com) to assume permissions on your behalf. For more
+     * information about the IAM role to use with the Amazon Redshift scheduler, see <a
+     * href="https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-identity-based.html">Using
+     * Identity-Based Policies for Amazon Redshift</a> in the <i>Amazon Redshift
+     * Cluster Management Guide</i>. </p>
+     */
+    inline void SetIamRole(const char* value) { m_iamRole.assign(value); }
+
+    /**
+     * <p>The IAM role to assume to run the scheduled action. This IAM role must have
+     * permission to run the Amazon Redshift API operation in the scheduled action.
+     * This IAM role must allow the Amazon Redshift scheduler (Principal
+     * scheduler.redshift.amazonaws.com) to assume permissions on your behalf. For more
+     * information about the IAM role to use with the Amazon Redshift scheduler, see <a
+     * href="https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-identity-based.html">Using
+     * Identity-Based Policies for Amazon Redshift</a> in the <i>Amazon Redshift
+     * Cluster Management Guide</i>. </p>
+     */
+    inline CreateScheduledActionResult& WithIamRole(const Aws::String& value) { SetIamRole(value); return *this;}
+
+    /**
+     * <p>The IAM role to assume to run the scheduled action. This IAM role must have
+     * permission to run the Amazon Redshift API operation in the scheduled action.
+     * This IAM role must allow the Amazon Redshift scheduler (Principal
+     * scheduler.redshift.amazonaws.com) to assume permissions on your behalf. For more
+     * information about the IAM role to use with the Amazon Redshift scheduler, see <a
+     * href="https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-identity-based.html">Using
+     * Identity-Based Policies for Amazon Redshift</a> in the <i>Amazon Redshift
+     * Cluster Management Guide</i>. </p>
+     */
+    inline CreateScheduledActionResult& WithIamRole(Aws::String&& value) { SetIamRole(std::move(value)); return *this;}
+
+    /**
+     * <p>The IAM role to assume to run the scheduled action. This IAM role must have
+     * permission to run the Amazon Redshift API operation in the scheduled action.
+     * This IAM role must allow the Amazon Redshift scheduler (Principal
+     * scheduler.redshift.amazonaws.com) to assume permissions on your behalf. For more
+     * information about the IAM role to use with the Amazon Redshift scheduler, see <a
+     * href="https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-identity-based.html">Using
+     * Identity-Based Policies for Amazon Redshift</a> in the <i>Amazon Redshift
+     * Cluster Management Guide</i>. </p>
+     */
+    inline CreateScheduledActionResult& WithIamRole(const char* value) { SetIamRole(value); return *this;}
+
+
+    /**
+     * <p>The description of the scheduled action. </p>
+     */
+    inline const Aws::String& GetScheduledActionDescription() const{ return m_scheduledActionDescription; }
+
+    /**
+     * <p>The description of the scheduled action. </p>
+     */
+    inline void SetScheduledActionDescription(const Aws::String& value) { m_scheduledActionDescription = value; }
+
+    /**
+     * <p>The description of the scheduled action. </p>
+     */
+    inline void SetScheduledActionDescription(Aws::String&& value) { m_scheduledActionDescription = std::move(value); }
+
+    /**
+     * <p>The description of the scheduled action. </p>
+     */
+    inline void SetScheduledActionDescription(const char* value) { m_scheduledActionDescription.assign(value); }
+
+    /**
+     * <p>The description of the scheduled action. </p>
+     */
+    inline CreateScheduledActionResult& WithScheduledActionDescription(const Aws::String& value) { SetScheduledActionDescription(value); return *this;}
+
+    /**
+     * <p>The description of the scheduled action. </p>
+     */
+    inline CreateScheduledActionResult& WithScheduledActionDescription(Aws::String&& value) { SetScheduledActionDescription(std::move(value)); return *this;}
+
+    /**
+     * <p>The description of the scheduled action. </p>
+     */
+    inline CreateScheduledActionResult& WithScheduledActionDescription(const char* value) { SetScheduledActionDescription(value); return *this;}
+
+
+    /**
+     * <p>The state of the scheduled action. For example, <code>DISABLED</code>. </p>
+     */
+    inline const ScheduledActionState& GetState() const{ return m_state; }
+
+    /**
+     * <p>The state of the scheduled action. For example, <code>DISABLED</code>. </p>
+     */
+    inline void SetState(const ScheduledActionState& value) { m_state = value; }
+
+    /**
+     * <p>The state of the scheduled action. For example, <code>DISABLED</code>. </p>
+     */
+    inline void SetState(ScheduledActionState&& value) { m_state = std::move(value); }
+
+    /**
+     * <p>The state of the scheduled action. For example, <code>DISABLED</code>. </p>
+     */
+    inline CreateScheduledActionResult& WithState(const ScheduledActionState& value) { SetState(value); return *this;}
+
+    /**
+     * <p>The state of the scheduled action. For example, <code>DISABLED</code>. </p>
+     */
+    inline CreateScheduledActionResult& WithState(ScheduledActionState&& value) { SetState(std::move(value)); return *this;}
+
+
+    /**
+     * <p>List of times when the scheduled action will run. </p>
+     */
+    inline const Aws::Vector<Aws::Utils::DateTime>& GetNextInvocations() const{ return m_nextInvocations; }
+
+    /**
+     * <p>List of times when the scheduled action will run. </p>
+     */
+    inline void SetNextInvocations(const Aws::Vector<Aws::Utils::DateTime>& value) { m_nextInvocations = value; }
+
+    /**
+     * <p>List of times when the scheduled action will run. </p>
+     */
+    inline void SetNextInvocations(Aws::Vector<Aws::Utils::DateTime>&& value) { m_nextInvocations = std::move(value); }
+
+    /**
+     * <p>List of times when the scheduled action will run. </p>
+     */
+    inline CreateScheduledActionResult& WithNextInvocations(const Aws::Vector<Aws::Utils::DateTime>& value) { SetNextInvocations(value); return *this;}
+
+    /**
+     * <p>List of times when the scheduled action will run. </p>
+     */
+    inline CreateScheduledActionResult& WithNextInvocations(Aws::Vector<Aws::Utils::DateTime>&& value) { SetNextInvocations(std::move(value)); return *this;}
+
+    /**
+     * <p>List of times when the scheduled action will run. </p>
+     */
+    inline CreateScheduledActionResult& AddNextInvocations(const Aws::Utils::DateTime& value) { m_nextInvocations.push_back(value); return *this; }
+
+    /**
+     * <p>List of times when the scheduled action will run. </p>
+     */
+    inline CreateScheduledActionResult& AddNextInvocations(Aws::Utils::DateTime&& value) { m_nextInvocations.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>The start time in UTC when the schedule is active. Before this time, the
+     * scheduled action does not trigger. </p>
+     */
+    inline const Aws::Utils::DateTime& GetStartTime() const{ return m_startTime; }
+
+    /**
+     * <p>The start time in UTC when the schedule is active. Before this time, the
+     * scheduled action does not trigger. </p>
+     */
+    inline void SetStartTime(const Aws::Utils::DateTime& value) { m_startTime = value; }
+
+    /**
+     * <p>The start time in UTC when the schedule is active. Before this time, the
+     * scheduled action does not trigger. </p>
+     */
+    inline void SetStartTime(Aws::Utils::DateTime&& value) { m_startTime = std::move(value); }
+
+    /**
+     * <p>The start time in UTC when the schedule is active. Before this time, the
+     * scheduled action does not trigger. </p>
+     */
+    inline CreateScheduledActionResult& WithStartTime(const Aws::Utils::DateTime& value) { SetStartTime(value); return *this;}
+
+    /**
+     * <p>The start time in UTC when the schedule is active. Before this time, the
+     * scheduled action does not trigger. </p>
+     */
+    inline CreateScheduledActionResult& WithStartTime(Aws::Utils::DateTime&& value) { SetStartTime(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The end time in UTC when the schedule is no longer active. After this time,
+     * the scheduled action does not trigger. </p>
+     */
+    inline const Aws::Utils::DateTime& GetEndTime() const{ return m_endTime; }
+
+    /**
+     * <p>The end time in UTC when the schedule is no longer active. After this time,
+     * the scheduled action does not trigger. </p>
+     */
+    inline void SetEndTime(const Aws::Utils::DateTime& value) { m_endTime = value; }
+
+    /**
+     * <p>The end time in UTC when the schedule is no longer active. After this time,
+     * the scheduled action does not trigger. </p>
+     */
+    inline void SetEndTime(Aws::Utils::DateTime&& value) { m_endTime = std::move(value); }
+
+    /**
+     * <p>The end time in UTC when the schedule is no longer active. After this time,
+     * the scheduled action does not trigger. </p>
+     */
+    inline CreateScheduledActionResult& WithEndTime(const Aws::Utils::DateTime& value) { SetEndTime(value); return *this;}
+
+    /**
+     * <p>The end time in UTC when the schedule is no longer active. After this time,
+     * the scheduled action does not trigger. </p>
+     */
+    inline CreateScheduledActionResult& WithEndTime(Aws::Utils::DateTime&& value) { SetEndTime(std::move(value)); return *this;}
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline CreateScheduledActionResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline CreateScheduledActionResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_scheduledActionName;
+
+    ScheduledActionType m_targetAction;
+
+    Aws::String m_schedule;
+
+    Aws::String m_iamRole;
+
+    Aws::String m_scheduledActionDescription;
+
+    ScheduledActionState m_state;
+
+    Aws::Vector<Aws::Utils::DateTime> m_nextInvocations;
+
+    Aws::Utils::DateTime m_startTime;
+
+    Aws::Utils::DateTime m_endTime;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/CreateSnapshotCopyGrantRequest.h

@@ -0,0 +1,229 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p>The result of the <code>CreateSnapshotCopyGrant</code> action.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/CreateSnapshotCopyGrantMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API CreateSnapshotCopyGrantRequest : public RedshiftRequest
+  {
+  public:
+    CreateSnapshotCopyGrantRequest();
+
+    // 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 "CreateSnapshotCopyGrant"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The name of the snapshot copy grant. This name must be unique in the region
+     * for the AWS account.</p> <p>Constraints:</p> <ul> <li> <p>Must contain from 1 to
+     * 63 alphanumeric characters or hyphens.</p> </li> <li> <p>Alphabetic characters
+     * must be lowercase.</p> </li> <li> <p>First character must be a letter.</p> </li>
+     * <li> <p>Cannot end with a hyphen or contain two consecutive hyphens.</p> </li>
+     * <li> <p>Must be unique for all clusters within an AWS account.</p> </li> </ul>
+     */
+    inline const Aws::String& GetSnapshotCopyGrantName() const{ return m_snapshotCopyGrantName; }
+
+    /**
+     * <p>The name of the snapshot copy grant. This name must be unique in the region
+     * for the AWS account.</p> <p>Constraints:</p> <ul> <li> <p>Must contain from 1 to
+     * 63 alphanumeric characters or hyphens.</p> </li> <li> <p>Alphabetic characters
+     * must be lowercase.</p> </li> <li> <p>First character must be a letter.</p> </li>
+     * <li> <p>Cannot end with a hyphen or contain two consecutive hyphens.</p> </li>
+     * <li> <p>Must be unique for all clusters within an AWS account.</p> </li> </ul>
+     */
+    inline bool SnapshotCopyGrantNameHasBeenSet() const { return m_snapshotCopyGrantNameHasBeenSet; }
+
+    /**
+     * <p>The name of the snapshot copy grant. This name must be unique in the region
+     * for the AWS account.</p> <p>Constraints:</p> <ul> <li> <p>Must contain from 1 to
+     * 63 alphanumeric characters or hyphens.</p> </li> <li> <p>Alphabetic characters
+     * must be lowercase.</p> </li> <li> <p>First character must be a letter.</p> </li>
+     * <li> <p>Cannot end with a hyphen or contain two consecutive hyphens.</p> </li>
+     * <li> <p>Must be unique for all clusters within an AWS account.</p> </li> </ul>
+     */
+    inline void SetSnapshotCopyGrantName(const Aws::String& value) { m_snapshotCopyGrantNameHasBeenSet = true; m_snapshotCopyGrantName = value; }
+
+    /**
+     * <p>The name of the snapshot copy grant. This name must be unique in the region
+     * for the AWS account.</p> <p>Constraints:</p> <ul> <li> <p>Must contain from 1 to
+     * 63 alphanumeric characters or hyphens.</p> </li> <li> <p>Alphabetic characters
+     * must be lowercase.</p> </li> <li> <p>First character must be a letter.</p> </li>
+     * <li> <p>Cannot end with a hyphen or contain two consecutive hyphens.</p> </li>
+     * <li> <p>Must be unique for all clusters within an AWS account.</p> </li> </ul>
+     */
+    inline void SetSnapshotCopyGrantName(Aws::String&& value) { m_snapshotCopyGrantNameHasBeenSet = true; m_snapshotCopyGrantName = std::move(value); }
+
+    /**
+     * <p>The name of the snapshot copy grant. This name must be unique in the region
+     * for the AWS account.</p> <p>Constraints:</p> <ul> <li> <p>Must contain from 1 to
+     * 63 alphanumeric characters or hyphens.</p> </li> <li> <p>Alphabetic characters
+     * must be lowercase.</p> </li> <li> <p>First character must be a letter.</p> </li>
+     * <li> <p>Cannot end with a hyphen or contain two consecutive hyphens.</p> </li>
+     * <li> <p>Must be unique for all clusters within an AWS account.</p> </li> </ul>
+     */
+    inline void SetSnapshotCopyGrantName(const char* value) { m_snapshotCopyGrantNameHasBeenSet = true; m_snapshotCopyGrantName.assign(value); }
+
+    /**
+     * <p>The name of the snapshot copy grant. This name must be unique in the region
+     * for the AWS account.</p> <p>Constraints:</p> <ul> <li> <p>Must contain from 1 to
+     * 63 alphanumeric characters or hyphens.</p> </li> <li> <p>Alphabetic characters
+     * must be lowercase.</p> </li> <li> <p>First character must be a letter.</p> </li>
+     * <li> <p>Cannot end with a hyphen or contain two consecutive hyphens.</p> </li>
+     * <li> <p>Must be unique for all clusters within an AWS account.</p> </li> </ul>
+     */
+    inline CreateSnapshotCopyGrantRequest& WithSnapshotCopyGrantName(const Aws::String& value) { SetSnapshotCopyGrantName(value); return *this;}
+
+    /**
+     * <p>The name of the snapshot copy grant. This name must be unique in the region
+     * for the AWS account.</p> <p>Constraints:</p> <ul> <li> <p>Must contain from 1 to
+     * 63 alphanumeric characters or hyphens.</p> </li> <li> <p>Alphabetic characters
+     * must be lowercase.</p> </li> <li> <p>First character must be a letter.</p> </li>
+     * <li> <p>Cannot end with a hyphen or contain two consecutive hyphens.</p> </li>
+     * <li> <p>Must be unique for all clusters within an AWS account.</p> </li> </ul>
+     */
+    inline CreateSnapshotCopyGrantRequest& WithSnapshotCopyGrantName(Aws::String&& value) { SetSnapshotCopyGrantName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the snapshot copy grant. This name must be unique in the region
+     * for the AWS account.</p> <p>Constraints:</p> <ul> <li> <p>Must contain from 1 to
+     * 63 alphanumeric characters or hyphens.</p> </li> <li> <p>Alphabetic characters
+     * must be lowercase.</p> </li> <li> <p>First character must be a letter.</p> </li>
+     * <li> <p>Cannot end with a hyphen or contain two consecutive hyphens.</p> </li>
+     * <li> <p>Must be unique for all clusters within an AWS account.</p> </li> </ul>
+     */
+    inline CreateSnapshotCopyGrantRequest& WithSnapshotCopyGrantName(const char* value) { SetSnapshotCopyGrantName(value); return *this;}
+
+
+    /**
+     * <p>The unique identifier of the customer master key (CMK) to which to grant
+     * Amazon Redshift permission. If no key is specified, the default key is used.</p>
+     */
+    inline const Aws::String& GetKmsKeyId() const{ return m_kmsKeyId; }
+
+    /**
+     * <p>The unique identifier of the customer master key (CMK) to which to grant
+     * Amazon Redshift permission. If no key is specified, the default key is used.</p>
+     */
+    inline bool KmsKeyIdHasBeenSet() const { return m_kmsKeyIdHasBeenSet; }
+
+    /**
+     * <p>The unique identifier of the customer master key (CMK) to which to grant
+     * Amazon Redshift permission. If no key is specified, the default key is used.</p>
+     */
+    inline void SetKmsKeyId(const Aws::String& value) { m_kmsKeyIdHasBeenSet = true; m_kmsKeyId = value; }
+
+    /**
+     * <p>The unique identifier of the customer master key (CMK) to which to grant
+     * Amazon Redshift permission. If no key is specified, the default key is used.</p>
+     */
+    inline void SetKmsKeyId(Aws::String&& value) { m_kmsKeyIdHasBeenSet = true; m_kmsKeyId = std::move(value); }
+
+    /**
+     * <p>The unique identifier of the customer master key (CMK) to which to grant
+     * Amazon Redshift permission. If no key is specified, the default key is used.</p>
+     */
+    inline void SetKmsKeyId(const char* value) { m_kmsKeyIdHasBeenSet = true; m_kmsKeyId.assign(value); }
+
+    /**
+     * <p>The unique identifier of the customer master key (CMK) to which to grant
+     * Amazon Redshift permission. If no key is specified, the default key is used.</p>
+     */
+    inline CreateSnapshotCopyGrantRequest& WithKmsKeyId(const Aws::String& value) { SetKmsKeyId(value); return *this;}
+
+    /**
+     * <p>The unique identifier of the customer master key (CMK) to which to grant
+     * Amazon Redshift permission. If no key is specified, the default key is used.</p>
+     */
+    inline CreateSnapshotCopyGrantRequest& WithKmsKeyId(Aws::String&& value) { SetKmsKeyId(std::move(value)); return *this;}
+
+    /**
+     * <p>The unique identifier of the customer master key (CMK) to which to grant
+     * Amazon Redshift permission. If no key is specified, the default key is used.</p>
+     */
+    inline CreateSnapshotCopyGrantRequest& WithKmsKeyId(const char* value) { SetKmsKeyId(value); return *this;}
+
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateSnapshotCopyGrantRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateSnapshotCopyGrantRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateSnapshotCopyGrantRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateSnapshotCopyGrantRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_snapshotCopyGrantName;
+    bool m_snapshotCopyGrantNameHasBeenSet;
+
+    Aws::String m_kmsKeyId;
+    bool m_kmsKeyIdHasBeenSet;
+
+    Aws::Vector<Tag> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/CreateSnapshotCopyGrantResult.h

@@ -0,0 +1,76 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/model/SnapshotCopyGrant.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  class AWS_REDSHIFT_API CreateSnapshotCopyGrantResult
+  {
+  public:
+    CreateSnapshotCopyGrantResult();
+    CreateSnapshotCopyGrantResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    CreateSnapshotCopyGrantResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    
+    inline const SnapshotCopyGrant& GetSnapshotCopyGrant() const{ return m_snapshotCopyGrant; }
+
+    
+    inline void SetSnapshotCopyGrant(const SnapshotCopyGrant& value) { m_snapshotCopyGrant = value; }
+
+    
+    inline void SetSnapshotCopyGrant(SnapshotCopyGrant&& value) { m_snapshotCopyGrant = std::move(value); }
+
+    
+    inline CreateSnapshotCopyGrantResult& WithSnapshotCopyGrant(const SnapshotCopyGrant& value) { SetSnapshotCopyGrant(value); return *this;}
+
+    
+    inline CreateSnapshotCopyGrantResult& WithSnapshotCopyGrant(SnapshotCopyGrant&& value) { SetSnapshotCopyGrant(std::move(value)); return *this;}
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline CreateSnapshotCopyGrantResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline CreateSnapshotCopyGrantResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    SnapshotCopyGrant m_snapshotCopyGrant;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/CreateSnapshotScheduleRequest.h

@@ -0,0 +1,291 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/redshift/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_REDSHIFT_API CreateSnapshotScheduleRequest : public RedshiftRequest
+  {
+  public:
+    CreateSnapshotScheduleRequest();
+
+    // 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 "CreateSnapshotSchedule"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The definition of the snapshot schedule. The definition is made up of
+     * schedule expressions, for example "cron(30 12 *)" or "rate(12 hours)". </p>
+     */
+    inline const Aws::Vector<Aws::String>& GetScheduleDefinitions() const{ return m_scheduleDefinitions; }
+
+    /**
+     * <p>The definition of the snapshot schedule. The definition is made up of
+     * schedule expressions, for example "cron(30 12 *)" or "rate(12 hours)". </p>
+     */
+    inline bool ScheduleDefinitionsHasBeenSet() const { return m_scheduleDefinitionsHasBeenSet; }
+
+    /**
+     * <p>The definition of the snapshot schedule. The definition is made up of
+     * schedule expressions, for example "cron(30 12 *)" or "rate(12 hours)". </p>
+     */
+    inline void SetScheduleDefinitions(const Aws::Vector<Aws::String>& value) { m_scheduleDefinitionsHasBeenSet = true; m_scheduleDefinitions = value; }
+
+    /**
+     * <p>The definition of the snapshot schedule. The definition is made up of
+     * schedule expressions, for example "cron(30 12 *)" or "rate(12 hours)". </p>
+     */
+    inline void SetScheduleDefinitions(Aws::Vector<Aws::String>&& value) { m_scheduleDefinitionsHasBeenSet = true; m_scheduleDefinitions = std::move(value); }
+
+    /**
+     * <p>The definition of the snapshot schedule. The definition is made up of
+     * schedule expressions, for example "cron(30 12 *)" or "rate(12 hours)". </p>
+     */
+    inline CreateSnapshotScheduleRequest& WithScheduleDefinitions(const Aws::Vector<Aws::String>& value) { SetScheduleDefinitions(value); return *this;}
+
+    /**
+     * <p>The definition of the snapshot schedule. The definition is made up of
+     * schedule expressions, for example "cron(30 12 *)" or "rate(12 hours)". </p>
+     */
+    inline CreateSnapshotScheduleRequest& WithScheduleDefinitions(Aws::Vector<Aws::String>&& value) { SetScheduleDefinitions(std::move(value)); return *this;}
+
+    /**
+     * <p>The definition of the snapshot schedule. The definition is made up of
+     * schedule expressions, for example "cron(30 12 *)" or "rate(12 hours)". </p>
+     */
+    inline CreateSnapshotScheduleRequest& AddScheduleDefinitions(const Aws::String& value) { m_scheduleDefinitionsHasBeenSet = true; m_scheduleDefinitions.push_back(value); return *this; }
+
+    /**
+     * <p>The definition of the snapshot schedule. The definition is made up of
+     * schedule expressions, for example "cron(30 12 *)" or "rate(12 hours)". </p>
+     */
+    inline CreateSnapshotScheduleRequest& AddScheduleDefinitions(Aws::String&& value) { m_scheduleDefinitionsHasBeenSet = true; m_scheduleDefinitions.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>The definition of the snapshot schedule. The definition is made up of
+     * schedule expressions, for example "cron(30 12 *)" or "rate(12 hours)". </p>
+     */
+    inline CreateSnapshotScheduleRequest& AddScheduleDefinitions(const char* value) { m_scheduleDefinitionsHasBeenSet = true; m_scheduleDefinitions.push_back(value); return *this; }
+
+
+    /**
+     * <p>A unique identifier for a snapshot schedule. Only alphanumeric characters are
+     * allowed for the identifier.</p>
+     */
+    inline const Aws::String& GetScheduleIdentifier() const{ return m_scheduleIdentifier; }
+
+    /**
+     * <p>A unique identifier for a snapshot schedule. Only alphanumeric characters are
+     * allowed for the identifier.</p>
+     */
+    inline bool ScheduleIdentifierHasBeenSet() const { return m_scheduleIdentifierHasBeenSet; }
+
+    /**
+     * <p>A unique identifier for a snapshot schedule. Only alphanumeric characters are
+     * allowed for the identifier.</p>
+     */
+    inline void SetScheduleIdentifier(const Aws::String& value) { m_scheduleIdentifierHasBeenSet = true; m_scheduleIdentifier = value; }
+
+    /**
+     * <p>A unique identifier for a snapshot schedule. Only alphanumeric characters are
+     * allowed for the identifier.</p>
+     */
+    inline void SetScheduleIdentifier(Aws::String&& value) { m_scheduleIdentifierHasBeenSet = true; m_scheduleIdentifier = std::move(value); }
+
+    /**
+     * <p>A unique identifier for a snapshot schedule. Only alphanumeric characters are
+     * allowed for the identifier.</p>
+     */
+    inline void SetScheduleIdentifier(const char* value) { m_scheduleIdentifierHasBeenSet = true; m_scheduleIdentifier.assign(value); }
+
+    /**
+     * <p>A unique identifier for a snapshot schedule. Only alphanumeric characters are
+     * allowed for the identifier.</p>
+     */
+    inline CreateSnapshotScheduleRequest& WithScheduleIdentifier(const Aws::String& value) { SetScheduleIdentifier(value); return *this;}
+
+    /**
+     * <p>A unique identifier for a snapshot schedule. Only alphanumeric characters are
+     * allowed for the identifier.</p>
+     */
+    inline CreateSnapshotScheduleRequest& WithScheduleIdentifier(Aws::String&& value) { SetScheduleIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>A unique identifier for a snapshot schedule. Only alphanumeric characters are
+     * allowed for the identifier.</p>
+     */
+    inline CreateSnapshotScheduleRequest& WithScheduleIdentifier(const char* value) { SetScheduleIdentifier(value); return *this;}
+
+
+    /**
+     * <p>The description of the snapshot schedule.</p>
+     */
+    inline const Aws::String& GetScheduleDescription() const{ return m_scheduleDescription; }
+
+    /**
+     * <p>The description of the snapshot schedule.</p>
+     */
+    inline bool ScheduleDescriptionHasBeenSet() const { return m_scheduleDescriptionHasBeenSet; }
+
+    /**
+     * <p>The description of the snapshot schedule.</p>
+     */
+    inline void SetScheduleDescription(const Aws::String& value) { m_scheduleDescriptionHasBeenSet = true; m_scheduleDescription = value; }
+
+    /**
+     * <p>The description of the snapshot schedule.</p>
+     */
+    inline void SetScheduleDescription(Aws::String&& value) { m_scheduleDescriptionHasBeenSet = true; m_scheduleDescription = std::move(value); }
+
+    /**
+     * <p>The description of the snapshot schedule.</p>
+     */
+    inline void SetScheduleDescription(const char* value) { m_scheduleDescriptionHasBeenSet = true; m_scheduleDescription.assign(value); }
+
+    /**
+     * <p>The description of the snapshot schedule.</p>
+     */
+    inline CreateSnapshotScheduleRequest& WithScheduleDescription(const Aws::String& value) { SetScheduleDescription(value); return *this;}
+
+    /**
+     * <p>The description of the snapshot schedule.</p>
+     */
+    inline CreateSnapshotScheduleRequest& WithScheduleDescription(Aws::String&& value) { SetScheduleDescription(std::move(value)); return *this;}
+
+    /**
+     * <p>The description of the snapshot schedule.</p>
+     */
+    inline CreateSnapshotScheduleRequest& WithScheduleDescription(const char* value) { SetScheduleDescription(value); return *this;}
+
+
+    /**
+     * <p>An optional set of tags you can use to search for the schedule.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>An optional set of tags you can use to search for the schedule.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>An optional set of tags you can use to search for the schedule.</p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>An optional set of tags you can use to search for the schedule.</p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>An optional set of tags you can use to search for the schedule.</p>
+     */
+    inline CreateSnapshotScheduleRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>An optional set of tags you can use to search for the schedule.</p>
+     */
+    inline CreateSnapshotScheduleRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>An optional set of tags you can use to search for the schedule.</p>
+     */
+    inline CreateSnapshotScheduleRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>An optional set of tags you can use to search for the schedule.</p>
+     */
+    inline CreateSnapshotScheduleRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p/>
+     */
+    inline bool GetDryRun() const{ return m_dryRun; }
+
+    /**
+     * <p/>
+     */
+    inline bool DryRunHasBeenSet() const { return m_dryRunHasBeenSet; }
+
+    /**
+     * <p/>
+     */
+    inline void SetDryRun(bool value) { m_dryRunHasBeenSet = true; m_dryRun = value; }
+
+    /**
+     * <p/>
+     */
+    inline CreateSnapshotScheduleRequest& WithDryRun(bool value) { SetDryRun(value); return *this;}
+
+
+    /**
+     * <p/>
+     */
+    inline int GetNextInvocations() const{ return m_nextInvocations; }
+
+    /**
+     * <p/>
+     */
+    inline bool NextInvocationsHasBeenSet() const { return m_nextInvocationsHasBeenSet; }
+
+    /**
+     * <p/>
+     */
+    inline void SetNextInvocations(int value) { m_nextInvocationsHasBeenSet = true; m_nextInvocations = value; }
+
+    /**
+     * <p/>
+     */
+    inline CreateSnapshotScheduleRequest& WithNextInvocations(int value) { SetNextInvocations(value); return *this;}
+
+  private:
+
+    Aws::Vector<Aws::String> m_scheduleDefinitions;
+    bool m_scheduleDefinitionsHasBeenSet;
+
+    Aws::String m_scheduleIdentifier;
+    bool m_scheduleIdentifierHasBeenSet;
+
+    Aws::String m_scheduleDescription;
+    bool m_scheduleDescriptionHasBeenSet;
+
+    Aws::Vector<Tag> m_tags;
+    bool m_tagsHasBeenSet;
+
+    bool m_dryRun;
+    bool m_dryRunHasBeenSet;
+
+    int m_nextInvocations;
+    bool m_nextInvocationsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/CreateSnapshotScheduleResult.h

@@ -0,0 +1,327 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <aws/redshift/model/Tag.h>
+#include <aws/core/utils/DateTime.h>
+#include <aws/redshift/model/ClusterAssociatedToSchedule.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  /**
+   * <p>Describes a snapshot schedule. You can set a regular interval for creating
+   * snapshots of a cluster. You can also schedule snapshots for specific dates.
+   * </p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/SnapshotSchedule">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API CreateSnapshotScheduleResult
+  {
+  public:
+    CreateSnapshotScheduleResult();
+    CreateSnapshotScheduleResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    CreateSnapshotScheduleResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    /**
+     * <p>A list of ScheduleDefinitions.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetScheduleDefinitions() const{ return m_scheduleDefinitions; }
+
+    /**
+     * <p>A list of ScheduleDefinitions.</p>
+     */
+    inline void SetScheduleDefinitions(const Aws::Vector<Aws::String>& value) { m_scheduleDefinitions = value; }
+
+    /**
+     * <p>A list of ScheduleDefinitions.</p>
+     */
+    inline void SetScheduleDefinitions(Aws::Vector<Aws::String>&& value) { m_scheduleDefinitions = std::move(value); }
+
+    /**
+     * <p>A list of ScheduleDefinitions.</p>
+     */
+    inline CreateSnapshotScheduleResult& WithScheduleDefinitions(const Aws::Vector<Aws::String>& value) { SetScheduleDefinitions(value); return *this;}
+
+    /**
+     * <p>A list of ScheduleDefinitions.</p>
+     */
+    inline CreateSnapshotScheduleResult& WithScheduleDefinitions(Aws::Vector<Aws::String>&& value) { SetScheduleDefinitions(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of ScheduleDefinitions.</p>
+     */
+    inline CreateSnapshotScheduleResult& AddScheduleDefinitions(const Aws::String& value) { m_scheduleDefinitions.push_back(value); return *this; }
+
+    /**
+     * <p>A list of ScheduleDefinitions.</p>
+     */
+    inline CreateSnapshotScheduleResult& AddScheduleDefinitions(Aws::String&& value) { m_scheduleDefinitions.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>A list of ScheduleDefinitions.</p>
+     */
+    inline CreateSnapshotScheduleResult& AddScheduleDefinitions(const char* value) { m_scheduleDefinitions.push_back(value); return *this; }
+
+
+    /**
+     * <p>A unique identifier for the schedule.</p>
+     */
+    inline const Aws::String& GetScheduleIdentifier() const{ return m_scheduleIdentifier; }
+
+    /**
+     * <p>A unique identifier for the schedule.</p>
+     */
+    inline void SetScheduleIdentifier(const Aws::String& value) { m_scheduleIdentifier = value; }
+
+    /**
+     * <p>A unique identifier for the schedule.</p>
+     */
+    inline void SetScheduleIdentifier(Aws::String&& value) { m_scheduleIdentifier = std::move(value); }
+
+    /**
+     * <p>A unique identifier for the schedule.</p>
+     */
+    inline void SetScheduleIdentifier(const char* value) { m_scheduleIdentifier.assign(value); }
+
+    /**
+     * <p>A unique identifier for the schedule.</p>
+     */
+    inline CreateSnapshotScheduleResult& WithScheduleIdentifier(const Aws::String& value) { SetScheduleIdentifier(value); return *this;}
+
+    /**
+     * <p>A unique identifier for the schedule.</p>
+     */
+    inline CreateSnapshotScheduleResult& WithScheduleIdentifier(Aws::String&& value) { SetScheduleIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>A unique identifier for the schedule.</p>
+     */
+    inline CreateSnapshotScheduleResult& WithScheduleIdentifier(const char* value) { SetScheduleIdentifier(value); return *this;}
+
+
+    /**
+     * <p>The description of the schedule.</p>
+     */
+    inline const Aws::String& GetScheduleDescription() const{ return m_scheduleDescription; }
+
+    /**
+     * <p>The description of the schedule.</p>
+     */
+    inline void SetScheduleDescription(const Aws::String& value) { m_scheduleDescription = value; }
+
+    /**
+     * <p>The description of the schedule.</p>
+     */
+    inline void SetScheduleDescription(Aws::String&& value) { m_scheduleDescription = std::move(value); }
+
+    /**
+     * <p>The description of the schedule.</p>
+     */
+    inline void SetScheduleDescription(const char* value) { m_scheduleDescription.assign(value); }
+
+    /**
+     * <p>The description of the schedule.</p>
+     */
+    inline CreateSnapshotScheduleResult& WithScheduleDescription(const Aws::String& value) { SetScheduleDescription(value); return *this;}
+
+    /**
+     * <p>The description of the schedule.</p>
+     */
+    inline CreateSnapshotScheduleResult& WithScheduleDescription(Aws::String&& value) { SetScheduleDescription(std::move(value)); return *this;}
+
+    /**
+     * <p>The description of the schedule.</p>
+     */
+    inline CreateSnapshotScheduleResult& WithScheduleDescription(const char* value) { SetScheduleDescription(value); return *this;}
+
+
+    /**
+     * <p>An optional set of tags describing the schedule.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>An optional set of tags describing the schedule.</p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tags = value; }
+
+    /**
+     * <p>An optional set of tags describing the schedule.</p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tags = std::move(value); }
+
+    /**
+     * <p>An optional set of tags describing the schedule.</p>
+     */
+    inline CreateSnapshotScheduleResult& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>An optional set of tags describing the schedule.</p>
+     */
+    inline CreateSnapshotScheduleResult& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>An optional set of tags describing the schedule.</p>
+     */
+    inline CreateSnapshotScheduleResult& AddTags(const Tag& value) { m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>An optional set of tags describing the schedule.</p>
+     */
+    inline CreateSnapshotScheduleResult& AddTags(Tag&& value) { m_tags.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p/>
+     */
+    inline const Aws::Vector<Aws::Utils::DateTime>& GetNextInvocations() const{ return m_nextInvocations; }
+
+    /**
+     * <p/>
+     */
+    inline void SetNextInvocations(const Aws::Vector<Aws::Utils::DateTime>& value) { m_nextInvocations = value; }
+
+    /**
+     * <p/>
+     */
+    inline void SetNextInvocations(Aws::Vector<Aws::Utils::DateTime>&& value) { m_nextInvocations = std::move(value); }
+
+    /**
+     * <p/>
+     */
+    inline CreateSnapshotScheduleResult& WithNextInvocations(const Aws::Vector<Aws::Utils::DateTime>& value) { SetNextInvocations(value); return *this;}
+
+    /**
+     * <p/>
+     */
+    inline CreateSnapshotScheduleResult& WithNextInvocations(Aws::Vector<Aws::Utils::DateTime>&& value) { SetNextInvocations(std::move(value)); return *this;}
+
+    /**
+     * <p/>
+     */
+    inline CreateSnapshotScheduleResult& AddNextInvocations(const Aws::Utils::DateTime& value) { m_nextInvocations.push_back(value); return *this; }
+
+    /**
+     * <p/>
+     */
+    inline CreateSnapshotScheduleResult& AddNextInvocations(Aws::Utils::DateTime&& value) { m_nextInvocations.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>The number of clusters associated with the schedule.</p>
+     */
+    inline int GetAssociatedClusterCount() const{ return m_associatedClusterCount; }
+
+    /**
+     * <p>The number of clusters associated with the schedule.</p>
+     */
+    inline void SetAssociatedClusterCount(int value) { m_associatedClusterCount = value; }
+
+    /**
+     * <p>The number of clusters associated with the schedule.</p>
+     */
+    inline CreateSnapshotScheduleResult& WithAssociatedClusterCount(int value) { SetAssociatedClusterCount(value); return *this;}
+
+
+    /**
+     * <p>A list of clusters associated with the schedule. A maximum of 100 clusters is
+     * returned.</p>
+     */
+    inline const Aws::Vector<ClusterAssociatedToSchedule>& GetAssociatedClusters() const{ return m_associatedClusters; }
+
+    /**
+     * <p>A list of clusters associated with the schedule. A maximum of 100 clusters is
+     * returned.</p>
+     */
+    inline void SetAssociatedClusters(const Aws::Vector<ClusterAssociatedToSchedule>& value) { m_associatedClusters = value; }
+
+    /**
+     * <p>A list of clusters associated with the schedule. A maximum of 100 clusters is
+     * returned.</p>
+     */
+    inline void SetAssociatedClusters(Aws::Vector<ClusterAssociatedToSchedule>&& value) { m_associatedClusters = std::move(value); }
+
+    /**
+     * <p>A list of clusters associated with the schedule. A maximum of 100 clusters is
+     * returned.</p>
+     */
+    inline CreateSnapshotScheduleResult& WithAssociatedClusters(const Aws::Vector<ClusterAssociatedToSchedule>& value) { SetAssociatedClusters(value); return *this;}
+
+    /**
+     * <p>A list of clusters associated with the schedule. A maximum of 100 clusters is
+     * returned.</p>
+     */
+    inline CreateSnapshotScheduleResult& WithAssociatedClusters(Aws::Vector<ClusterAssociatedToSchedule>&& value) { SetAssociatedClusters(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of clusters associated with the schedule. A maximum of 100 clusters is
+     * returned.</p>
+     */
+    inline CreateSnapshotScheduleResult& AddAssociatedClusters(const ClusterAssociatedToSchedule& value) { m_associatedClusters.push_back(value); return *this; }
+
+    /**
+     * <p>A list of clusters associated with the schedule. A maximum of 100 clusters is
+     * returned.</p>
+     */
+    inline CreateSnapshotScheduleResult& AddAssociatedClusters(ClusterAssociatedToSchedule&& value) { m_associatedClusters.push_back(std::move(value)); return *this; }
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline CreateSnapshotScheduleResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline CreateSnapshotScheduleResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    Aws::Vector<Aws::String> m_scheduleDefinitions;
+
+    Aws::String m_scheduleIdentifier;
+
+    Aws::String m_scheduleDescription;
+
+    Aws::Vector<Tag> m_tags;
+
+    Aws::Vector<Aws::Utils::DateTime> m_nextInvocations;
+
+    int m_associatedClusterCount;
+
+    Aws::Vector<ClusterAssociatedToSchedule> m_associatedClusters;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/CreateTagsRequest.h

@@ -0,0 +1,193 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p>Contains the output from the <code>CreateTags</code> action. </p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/CreateTagsMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API CreateTagsRequest : public RedshiftRequest
+  {
+  public:
+    CreateTagsRequest();
+
+    // 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 "CreateTags"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The Amazon Resource Name (ARN) to which you want to add the tag or tags. For
+     * example, <code>arn:aws:redshift:us-east-2:123456789:cluster:t1</code>. </p>
+     */
+    inline const Aws::String& GetResourceName() const{ return m_resourceName; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) to which you want to add the tag or tags. For
+     * example, <code>arn:aws:redshift:us-east-2:123456789:cluster:t1</code>. </p>
+     */
+    inline bool ResourceNameHasBeenSet() const { return m_resourceNameHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) to which you want to add the tag or tags. For
+     * example, <code>arn:aws:redshift:us-east-2:123456789:cluster:t1</code>. </p>
+     */
+    inline void SetResourceName(const Aws::String& value) { m_resourceNameHasBeenSet = true; m_resourceName = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) to which you want to add the tag or tags. For
+     * example, <code>arn:aws:redshift:us-east-2:123456789:cluster:t1</code>. </p>
+     */
+    inline void SetResourceName(Aws::String&& value) { m_resourceNameHasBeenSet = true; m_resourceName = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) to which you want to add the tag or tags. For
+     * example, <code>arn:aws:redshift:us-east-2:123456789:cluster:t1</code>. </p>
+     */
+    inline void SetResourceName(const char* value) { m_resourceNameHasBeenSet = true; m_resourceName.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) to which you want to add the tag or tags. For
+     * example, <code>arn:aws:redshift:us-east-2:123456789:cluster:t1</code>. </p>
+     */
+    inline CreateTagsRequest& WithResourceName(const Aws::String& value) { SetResourceName(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) to which you want to add the tag or tags. For
+     * example, <code>arn:aws:redshift:us-east-2:123456789:cluster:t1</code>. </p>
+     */
+    inline CreateTagsRequest& WithResourceName(Aws::String&& value) { SetResourceName(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) to which you want to add the tag or tags. For
+     * example, <code>arn:aws:redshift:us-east-2:123456789:cluster:t1</code>. </p>
+     */
+    inline CreateTagsRequest& WithResourceName(const char* value) { SetResourceName(value); return *this;}
+
+
+    /**
+     * <p>One or more name/value pairs to add as tags to the specified resource. Each
+     * tag name is passed in with the parameter <code>Key</code> and the corresponding
+     * value is passed in with the parameter <code>Value</code>. The <code>Key</code>
+     * and <code>Value</code> parameters are separated by a comma (,). Separate
+     * multiple tags with a space. For example, <code>--tags
+     * "Key"="owner","Value"="admin" "Key"="environment","Value"="test"
+     * "Key"="version","Value"="1.0"</code>. </p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>One or more name/value pairs to add as tags to the specified resource. Each
+     * tag name is passed in with the parameter <code>Key</code> and the corresponding
+     * value is passed in with the parameter <code>Value</code>. The <code>Key</code>
+     * and <code>Value</code> parameters are separated by a comma (,). Separate
+     * multiple tags with a space. For example, <code>--tags
+     * "Key"="owner","Value"="admin" "Key"="environment","Value"="test"
+     * "Key"="version","Value"="1.0"</code>. </p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>One or more name/value pairs to add as tags to the specified resource. Each
+     * tag name is passed in with the parameter <code>Key</code> and the corresponding
+     * value is passed in with the parameter <code>Value</code>. The <code>Key</code>
+     * and <code>Value</code> parameters are separated by a comma (,). Separate
+     * multiple tags with a space. For example, <code>--tags
+     * "Key"="owner","Value"="admin" "Key"="environment","Value"="test"
+     * "Key"="version","Value"="1.0"</code>. </p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>One or more name/value pairs to add as tags to the specified resource. Each
+     * tag name is passed in with the parameter <code>Key</code> and the corresponding
+     * value is passed in with the parameter <code>Value</code>. The <code>Key</code>
+     * and <code>Value</code> parameters are separated by a comma (,). Separate
+     * multiple tags with a space. For example, <code>--tags
+     * "Key"="owner","Value"="admin" "Key"="environment","Value"="test"
+     * "Key"="version","Value"="1.0"</code>. </p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>One or more name/value pairs to add as tags to the specified resource. Each
+     * tag name is passed in with the parameter <code>Key</code> and the corresponding
+     * value is passed in with the parameter <code>Value</code>. The <code>Key</code>
+     * and <code>Value</code> parameters are separated by a comma (,). Separate
+     * multiple tags with a space. For example, <code>--tags
+     * "Key"="owner","Value"="admin" "Key"="environment","Value"="test"
+     * "Key"="version","Value"="1.0"</code>. </p>
+     */
+    inline CreateTagsRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>One or more name/value pairs to add as tags to the specified resource. Each
+     * tag name is passed in with the parameter <code>Key</code> and the corresponding
+     * value is passed in with the parameter <code>Value</code>. The <code>Key</code>
+     * and <code>Value</code> parameters are separated by a comma (,). Separate
+     * multiple tags with a space. For example, <code>--tags
+     * "Key"="owner","Value"="admin" "Key"="environment","Value"="test"
+     * "Key"="version","Value"="1.0"</code>. </p>
+     */
+    inline CreateTagsRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>One or more name/value pairs to add as tags to the specified resource. Each
+     * tag name is passed in with the parameter <code>Key</code> and the corresponding
+     * value is passed in with the parameter <code>Value</code>. The <code>Key</code>
+     * and <code>Value</code> parameters are separated by a comma (,). Separate
+     * multiple tags with a space. For example, <code>--tags
+     * "Key"="owner","Value"="admin" "Key"="environment","Value"="test"
+     * "Key"="version","Value"="1.0"</code>. </p>
+     */
+    inline CreateTagsRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>One or more name/value pairs to add as tags to the specified resource. Each
+     * tag name is passed in with the parameter <code>Key</code> and the corresponding
+     * value is passed in with the parameter <code>Value</code>. The <code>Key</code>
+     * and <code>Value</code> parameters are separated by a comma (,). Separate
+     * multiple tags with a space. For example, <code>--tags
+     * "Key"="owner","Value"="admin" "Key"="environment","Value"="test"
+     * "Key"="version","Value"="1.0"</code>. </p>
+     */
+    inline CreateTagsRequest& 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 Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/CreateUsageLimitRequest.h

@@ -0,0 +1,337 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/redshift/model/UsageLimitFeatureType.h>
+#include <aws/redshift/model/UsageLimitLimitType.h>
+#include <aws/redshift/model/UsageLimitPeriod.h>
+#include <aws/redshift/model/UsageLimitBreachAction.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_REDSHIFT_API CreateUsageLimitRequest : public RedshiftRequest
+  {
+  public:
+    CreateUsageLimitRequest();
+
+    // 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 "CreateUsageLimit"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The identifier of the cluster that you want to limit usage.</p>
+     */
+    inline const Aws::String& GetClusterIdentifier() const{ return m_clusterIdentifier; }
+
+    /**
+     * <p>The identifier of the cluster that you want to limit usage.</p>
+     */
+    inline bool ClusterIdentifierHasBeenSet() const { return m_clusterIdentifierHasBeenSet; }
+
+    /**
+     * <p>The identifier of the cluster that you want to limit usage.</p>
+     */
+    inline void SetClusterIdentifier(const Aws::String& value) { m_clusterIdentifierHasBeenSet = true; m_clusterIdentifier = value; }
+
+    /**
+     * <p>The identifier of the cluster that you want to limit usage.</p>
+     */
+    inline void SetClusterIdentifier(Aws::String&& value) { m_clusterIdentifierHasBeenSet = true; m_clusterIdentifier = std::move(value); }
+
+    /**
+     * <p>The identifier of the cluster that you want to limit usage.</p>
+     */
+    inline void SetClusterIdentifier(const char* value) { m_clusterIdentifierHasBeenSet = true; m_clusterIdentifier.assign(value); }
+
+    /**
+     * <p>The identifier of the cluster that you want to limit usage.</p>
+     */
+    inline CreateUsageLimitRequest& WithClusterIdentifier(const Aws::String& value) { SetClusterIdentifier(value); return *this;}
+
+    /**
+     * <p>The identifier of the cluster that you want to limit usage.</p>
+     */
+    inline CreateUsageLimitRequest& WithClusterIdentifier(Aws::String&& value) { SetClusterIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>The identifier of the cluster that you want to limit usage.</p>
+     */
+    inline CreateUsageLimitRequest& WithClusterIdentifier(const char* value) { SetClusterIdentifier(value); return *this;}
+
+
+    /**
+     * <p>The Amazon Redshift feature that you want to limit.</p>
+     */
+    inline const UsageLimitFeatureType& GetFeatureType() const{ return m_featureType; }
+
+    /**
+     * <p>The Amazon Redshift feature that you want to limit.</p>
+     */
+    inline bool FeatureTypeHasBeenSet() const { return m_featureTypeHasBeenSet; }
+
+    /**
+     * <p>The Amazon Redshift feature that you want to limit.</p>
+     */
+    inline void SetFeatureType(const UsageLimitFeatureType& value) { m_featureTypeHasBeenSet = true; m_featureType = value; }
+
+    /**
+     * <p>The Amazon Redshift feature that you want to limit.</p>
+     */
+    inline void SetFeatureType(UsageLimitFeatureType&& value) { m_featureTypeHasBeenSet = true; m_featureType = std::move(value); }
+
+    /**
+     * <p>The Amazon Redshift feature that you want to limit.</p>
+     */
+    inline CreateUsageLimitRequest& WithFeatureType(const UsageLimitFeatureType& value) { SetFeatureType(value); return *this;}
+
+    /**
+     * <p>The Amazon Redshift feature that you want to limit.</p>
+     */
+    inline CreateUsageLimitRequest& WithFeatureType(UsageLimitFeatureType&& value) { SetFeatureType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The type of limit. Depending on the feature type, this can be based on a time
+     * duration or data size. If <code>FeatureType</code> is <code>spectrum</code>,
+     * then <code>LimitType</code> must be <code>data-scanned</code>. If
+     * <code>FeatureType</code> is <code>concurrency-scaling</code>, then
+     * <code>LimitType</code> must be <code>time</code>. </p>
+     */
+    inline const UsageLimitLimitType& GetLimitType() const{ return m_limitType; }
+
+    /**
+     * <p>The type of limit. Depending on the feature type, this can be based on a time
+     * duration or data size. If <code>FeatureType</code> is <code>spectrum</code>,
+     * then <code>LimitType</code> must be <code>data-scanned</code>. If
+     * <code>FeatureType</code> is <code>concurrency-scaling</code>, then
+     * <code>LimitType</code> must be <code>time</code>. </p>
+     */
+    inline bool LimitTypeHasBeenSet() const { return m_limitTypeHasBeenSet; }
+
+    /**
+     * <p>The type of limit. Depending on the feature type, this can be based on a time
+     * duration or data size. If <code>FeatureType</code> is <code>spectrum</code>,
+     * then <code>LimitType</code> must be <code>data-scanned</code>. If
+     * <code>FeatureType</code> is <code>concurrency-scaling</code>, then
+     * <code>LimitType</code> must be <code>time</code>. </p>
+     */
+    inline void SetLimitType(const UsageLimitLimitType& value) { m_limitTypeHasBeenSet = true; m_limitType = value; }
+
+    /**
+     * <p>The type of limit. Depending on the feature type, this can be based on a time
+     * duration or data size. If <code>FeatureType</code> is <code>spectrum</code>,
+     * then <code>LimitType</code> must be <code>data-scanned</code>. If
+     * <code>FeatureType</code> is <code>concurrency-scaling</code>, then
+     * <code>LimitType</code> must be <code>time</code>. </p>
+     */
+    inline void SetLimitType(UsageLimitLimitType&& value) { m_limitTypeHasBeenSet = true; m_limitType = std::move(value); }
+
+    /**
+     * <p>The type of limit. Depending on the feature type, this can be based on a time
+     * duration or data size. If <code>FeatureType</code> is <code>spectrum</code>,
+     * then <code>LimitType</code> must be <code>data-scanned</code>. If
+     * <code>FeatureType</code> is <code>concurrency-scaling</code>, then
+     * <code>LimitType</code> must be <code>time</code>. </p>
+     */
+    inline CreateUsageLimitRequest& WithLimitType(const UsageLimitLimitType& value) { SetLimitType(value); return *this;}
+
+    /**
+     * <p>The type of limit. Depending on the feature type, this can be based on a time
+     * duration or data size. If <code>FeatureType</code> is <code>spectrum</code>,
+     * then <code>LimitType</code> must be <code>data-scanned</code>. If
+     * <code>FeatureType</code> is <code>concurrency-scaling</code>, then
+     * <code>LimitType</code> must be <code>time</code>. </p>
+     */
+    inline CreateUsageLimitRequest& WithLimitType(UsageLimitLimitType&& value) { SetLimitType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The limit amount. If time-based, this amount is in minutes. If data-based,
+     * this amount is in terabytes (TB). The value must be a positive number. </p>
+     */
+    inline long long GetAmount() const{ return m_amount; }
+
+    /**
+     * <p>The limit amount. If time-based, this amount is in minutes. If data-based,
+     * this amount is in terabytes (TB). The value must be a positive number. </p>
+     */
+    inline bool AmountHasBeenSet() const { return m_amountHasBeenSet; }
+
+    /**
+     * <p>The limit amount. If time-based, this amount is in minutes. If data-based,
+     * this amount is in terabytes (TB). The value must be a positive number. </p>
+     */
+    inline void SetAmount(long long value) { m_amountHasBeenSet = true; m_amount = value; }
+
+    /**
+     * <p>The limit amount. If time-based, this amount is in minutes. If data-based,
+     * this amount is in terabytes (TB). The value must be a positive number. </p>
+     */
+    inline CreateUsageLimitRequest& WithAmount(long long value) { SetAmount(value); return *this;}
+
+
+    /**
+     * <p>The time period that the amount applies to. A <code>weekly</code> period
+     * begins on Sunday. The default is <code>monthly</code>. </p>
+     */
+    inline const UsageLimitPeriod& GetPeriod() const{ return m_period; }
+
+    /**
+     * <p>The time period that the amount applies to. A <code>weekly</code> period
+     * begins on Sunday. The default is <code>monthly</code>. </p>
+     */
+    inline bool PeriodHasBeenSet() const { return m_periodHasBeenSet; }
+
+    /**
+     * <p>The time period that the amount applies to. A <code>weekly</code> period
+     * begins on Sunday. The default is <code>monthly</code>. </p>
+     */
+    inline void SetPeriod(const UsageLimitPeriod& value) { m_periodHasBeenSet = true; m_period = value; }
+
+    /**
+     * <p>The time period that the amount applies to. A <code>weekly</code> period
+     * begins on Sunday. The default is <code>monthly</code>. </p>
+     */
+    inline void SetPeriod(UsageLimitPeriod&& value) { m_periodHasBeenSet = true; m_period = std::move(value); }
+
+    /**
+     * <p>The time period that the amount applies to. A <code>weekly</code> period
+     * begins on Sunday. The default is <code>monthly</code>. </p>
+     */
+    inline CreateUsageLimitRequest& WithPeriod(const UsageLimitPeriod& value) { SetPeriod(value); return *this;}
+
+    /**
+     * <p>The time period that the amount applies to. A <code>weekly</code> period
+     * begins on Sunday. The default is <code>monthly</code>. </p>
+     */
+    inline CreateUsageLimitRequest& WithPeriod(UsageLimitPeriod&& value) { SetPeriod(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The action that Amazon Redshift takes when the limit is reached. The default
+     * is log. For more information about this parameter, see <a>UsageLimit</a>.</p>
+     */
+    inline const UsageLimitBreachAction& GetBreachAction() const{ return m_breachAction; }
+
+    /**
+     * <p>The action that Amazon Redshift takes when the limit is reached. The default
+     * is log. For more information about this parameter, see <a>UsageLimit</a>.</p>
+     */
+    inline bool BreachActionHasBeenSet() const { return m_breachActionHasBeenSet; }
+
+    /**
+     * <p>The action that Amazon Redshift takes when the limit is reached. The default
+     * is log. For more information about this parameter, see <a>UsageLimit</a>.</p>
+     */
+    inline void SetBreachAction(const UsageLimitBreachAction& value) { m_breachActionHasBeenSet = true; m_breachAction = value; }
+
+    /**
+     * <p>The action that Amazon Redshift takes when the limit is reached. The default
+     * is log. For more information about this parameter, see <a>UsageLimit</a>.</p>
+     */
+    inline void SetBreachAction(UsageLimitBreachAction&& value) { m_breachActionHasBeenSet = true; m_breachAction = std::move(value); }
+
+    /**
+     * <p>The action that Amazon Redshift takes when the limit is reached. The default
+     * is log. For more information about this parameter, see <a>UsageLimit</a>.</p>
+     */
+    inline CreateUsageLimitRequest& WithBreachAction(const UsageLimitBreachAction& value) { SetBreachAction(value); return *this;}
+
+    /**
+     * <p>The action that Amazon Redshift takes when the limit is reached. The default
+     * is log. For more information about this parameter, see <a>UsageLimit</a>.</p>
+     */
+    inline CreateUsageLimitRequest& WithBreachAction(UsageLimitBreachAction&& value) { SetBreachAction(std::move(value)); return *this;}
+
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateUsageLimitRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateUsageLimitRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateUsageLimitRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateUsageLimitRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_clusterIdentifier;
+    bool m_clusterIdentifierHasBeenSet;
+
+    UsageLimitFeatureType m_featureType;
+    bool m_featureTypeHasBeenSet;
+
+    UsageLimitLimitType m_limitType;
+    bool m_limitTypeHasBeenSet;
+
+    long long m_amount;
+    bool m_amountHasBeenSet;
+
+    UsageLimitPeriod m_period;
+    bool m_periodHasBeenSet;
+
+    UsageLimitBreachAction m_breachAction;
+    bool m_breachActionHasBeenSet;
+
+    Aws::Vector<Tag> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/CreateUsageLimitResult.h

@@ -0,0 +1,346 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/redshift/model/UsageLimitFeatureType.h>
+#include <aws/redshift/model/UsageLimitLimitType.h>
+#include <aws/redshift/model/UsageLimitPeriod.h>
+#include <aws/redshift/model/UsageLimitBreachAction.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <aws/redshift/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  /**
+   * <p>Describes a usage limit object for a cluster. </p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/UsageLimit">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API CreateUsageLimitResult
+  {
+  public:
+    CreateUsageLimitResult();
+    CreateUsageLimitResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    CreateUsageLimitResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    /**
+     * <p>The identifier of the usage limit.</p>
+     */
+    inline const Aws::String& GetUsageLimitId() const{ return m_usageLimitId; }
+
+    /**
+     * <p>The identifier of the usage limit.</p>
+     */
+    inline void SetUsageLimitId(const Aws::String& value) { m_usageLimitId = value; }
+
+    /**
+     * <p>The identifier of the usage limit.</p>
+     */
+    inline void SetUsageLimitId(Aws::String&& value) { m_usageLimitId = std::move(value); }
+
+    /**
+     * <p>The identifier of the usage limit.</p>
+     */
+    inline void SetUsageLimitId(const char* value) { m_usageLimitId.assign(value); }
+
+    /**
+     * <p>The identifier of the usage limit.</p>
+     */
+    inline CreateUsageLimitResult& WithUsageLimitId(const Aws::String& value) { SetUsageLimitId(value); return *this;}
+
+    /**
+     * <p>The identifier of the usage limit.</p>
+     */
+    inline CreateUsageLimitResult& WithUsageLimitId(Aws::String&& value) { SetUsageLimitId(std::move(value)); return *this;}
+
+    /**
+     * <p>The identifier of the usage limit.</p>
+     */
+    inline CreateUsageLimitResult& WithUsageLimitId(const char* value) { SetUsageLimitId(value); return *this;}
+
+
+    /**
+     * <p>The identifier of the cluster with a usage limit.</p>
+     */
+    inline const Aws::String& GetClusterIdentifier() const{ return m_clusterIdentifier; }
+
+    /**
+     * <p>The identifier of the cluster with a usage limit.</p>
+     */
+    inline void SetClusterIdentifier(const Aws::String& value) { m_clusterIdentifier = value; }
+
+    /**
+     * <p>The identifier of the cluster with a usage limit.</p>
+     */
+    inline void SetClusterIdentifier(Aws::String&& value) { m_clusterIdentifier = std::move(value); }
+
+    /**
+     * <p>The identifier of the cluster with a usage limit.</p>
+     */
+    inline void SetClusterIdentifier(const char* value) { m_clusterIdentifier.assign(value); }
+
+    /**
+     * <p>The identifier of the cluster with a usage limit.</p>
+     */
+    inline CreateUsageLimitResult& WithClusterIdentifier(const Aws::String& value) { SetClusterIdentifier(value); return *this;}
+
+    /**
+     * <p>The identifier of the cluster with a usage limit.</p>
+     */
+    inline CreateUsageLimitResult& WithClusterIdentifier(Aws::String&& value) { SetClusterIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>The identifier of the cluster with a usage limit.</p>
+     */
+    inline CreateUsageLimitResult& WithClusterIdentifier(const char* value) { SetClusterIdentifier(value); return *this;}
+
+
+    /**
+     * <p>The Amazon Redshift feature to which the limit applies.</p>
+     */
+    inline const UsageLimitFeatureType& GetFeatureType() const{ return m_featureType; }
+
+    /**
+     * <p>The Amazon Redshift feature to which the limit applies.</p>
+     */
+    inline void SetFeatureType(const UsageLimitFeatureType& value) { m_featureType = value; }
+
+    /**
+     * <p>The Amazon Redshift feature to which the limit applies.</p>
+     */
+    inline void SetFeatureType(UsageLimitFeatureType&& value) { m_featureType = std::move(value); }
+
+    /**
+     * <p>The Amazon Redshift feature to which the limit applies.</p>
+     */
+    inline CreateUsageLimitResult& WithFeatureType(const UsageLimitFeatureType& value) { SetFeatureType(value); return *this;}
+
+    /**
+     * <p>The Amazon Redshift feature to which the limit applies.</p>
+     */
+    inline CreateUsageLimitResult& WithFeatureType(UsageLimitFeatureType&& value) { SetFeatureType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The type of limit. Depending on the feature type, this can be based on a time
+     * duration or data size.</p>
+     */
+    inline const UsageLimitLimitType& GetLimitType() const{ return m_limitType; }
+
+    /**
+     * <p>The type of limit. Depending on the feature type, this can be based on a time
+     * duration or data size.</p>
+     */
+    inline void SetLimitType(const UsageLimitLimitType& value) { m_limitType = value; }
+
+    /**
+     * <p>The type of limit. Depending on the feature type, this can be based on a time
+     * duration or data size.</p>
+     */
+    inline void SetLimitType(UsageLimitLimitType&& value) { m_limitType = std::move(value); }
+
+    /**
+     * <p>The type of limit. Depending on the feature type, this can be based on a time
+     * duration or data size.</p>
+     */
+    inline CreateUsageLimitResult& WithLimitType(const UsageLimitLimitType& value) { SetLimitType(value); return *this;}
+
+    /**
+     * <p>The type of limit. Depending on the feature type, this can be based on a time
+     * duration or data size.</p>
+     */
+    inline CreateUsageLimitResult& WithLimitType(UsageLimitLimitType&& value) { SetLimitType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The limit amount. If time-based, this amount is in minutes. If data-based,
+     * this amount is in terabytes (TB).</p>
+     */
+    inline long long GetAmount() const{ return m_amount; }
+
+    /**
+     * <p>The limit amount. If time-based, this amount is in minutes. If data-based,
+     * this amount is in terabytes (TB).</p>
+     */
+    inline void SetAmount(long long value) { m_amount = value; }
+
+    /**
+     * <p>The limit amount. If time-based, this amount is in minutes. If data-based,
+     * this amount is in terabytes (TB).</p>
+     */
+    inline CreateUsageLimitResult& WithAmount(long long value) { SetAmount(value); return *this;}
+
+
+    /**
+     * <p>The time period that the amount applies to. A <code>weekly</code> period
+     * begins on Sunday. The default is <code>monthly</code>. </p>
+     */
+    inline const UsageLimitPeriod& GetPeriod() const{ return m_period; }
+
+    /**
+     * <p>The time period that the amount applies to. A <code>weekly</code> period
+     * begins on Sunday. The default is <code>monthly</code>. </p>
+     */
+    inline void SetPeriod(const UsageLimitPeriod& value) { m_period = value; }
+
+    /**
+     * <p>The time period that the amount applies to. A <code>weekly</code> period
+     * begins on Sunday. The default is <code>monthly</code>. </p>
+     */
+    inline void SetPeriod(UsageLimitPeriod&& value) { m_period = std::move(value); }
+
+    /**
+     * <p>The time period that the amount applies to. A <code>weekly</code> period
+     * begins on Sunday. The default is <code>monthly</code>. </p>
+     */
+    inline CreateUsageLimitResult& WithPeriod(const UsageLimitPeriod& value) { SetPeriod(value); return *this;}
+
+    /**
+     * <p>The time period that the amount applies to. A <code>weekly</code> period
+     * begins on Sunday. The default is <code>monthly</code>. </p>
+     */
+    inline CreateUsageLimitResult& WithPeriod(UsageLimitPeriod&& value) { SetPeriod(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The action that Amazon Redshift takes when the limit is reached. Possible
+     * values are: </p> <ul> <li> <p> <b>log</b> - To log an event in a system table.
+     * The default is log.</p> </li> <li> <p> <b>emit-metric</b> - To emit CloudWatch
+     * metrics.</p> </li> <li> <p> <b>disable</b> - To disable the feature until the
+     * next usage period begins.</p> </li> </ul>
+     */
+    inline const UsageLimitBreachAction& GetBreachAction() const{ return m_breachAction; }
+
+    /**
+     * <p>The action that Amazon Redshift takes when the limit is reached. Possible
+     * values are: </p> <ul> <li> <p> <b>log</b> - To log an event in a system table.
+     * The default is log.</p> </li> <li> <p> <b>emit-metric</b> - To emit CloudWatch
+     * metrics.</p> </li> <li> <p> <b>disable</b> - To disable the feature until the
+     * next usage period begins.</p> </li> </ul>
+     */
+    inline void SetBreachAction(const UsageLimitBreachAction& value) { m_breachAction = value; }
+
+    /**
+     * <p>The action that Amazon Redshift takes when the limit is reached. Possible
+     * values are: </p> <ul> <li> <p> <b>log</b> - To log an event in a system table.
+     * The default is log.</p> </li> <li> <p> <b>emit-metric</b> - To emit CloudWatch
+     * metrics.</p> </li> <li> <p> <b>disable</b> - To disable the feature until the
+     * next usage period begins.</p> </li> </ul>
+     */
+    inline void SetBreachAction(UsageLimitBreachAction&& value) { m_breachAction = std::move(value); }
+
+    /**
+     * <p>The action that Amazon Redshift takes when the limit is reached. Possible
+     * values are: </p> <ul> <li> <p> <b>log</b> - To log an event in a system table.
+     * The default is log.</p> </li> <li> <p> <b>emit-metric</b> - To emit CloudWatch
+     * metrics.</p> </li> <li> <p> <b>disable</b> - To disable the feature until the
+     * next usage period begins.</p> </li> </ul>
+     */
+    inline CreateUsageLimitResult& WithBreachAction(const UsageLimitBreachAction& value) { SetBreachAction(value); return *this;}
+
+    /**
+     * <p>The action that Amazon Redshift takes when the limit is reached. Possible
+     * values are: </p> <ul> <li> <p> <b>log</b> - To log an event in a system table.
+     * The default is log.</p> </li> <li> <p> <b>emit-metric</b> - To emit CloudWatch
+     * metrics.</p> </li> <li> <p> <b>disable</b> - To disable the feature until the
+     * next usage period begins.</p> </li> </ul>
+     */
+    inline CreateUsageLimitResult& WithBreachAction(UsageLimitBreachAction&& value) { SetBreachAction(std::move(value)); return *this;}
+
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tags = value; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tags = std::move(value); }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateUsageLimitResult& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateUsageLimitResult& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateUsageLimitResult& AddTags(const Tag& value) { m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>A list of tag instances.</p>
+     */
+    inline CreateUsageLimitResult& AddTags(Tag&& value) { m_tags.push_back(std::move(value)); return *this; }
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline CreateUsageLimitResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline CreateUsageLimitResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_usageLimitId;
+
+    Aws::String m_clusterIdentifier;
+
+    UsageLimitFeatureType m_featureType;
+
+    UsageLimitLimitType m_limitType;
+
+    long long m_amount;
+
+    UsageLimitPeriod m_period;
+
+    UsageLimitBreachAction m_breachAction;
+
+    Aws::Vector<Tag> m_tags;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DataTransferProgress.h

@@ -0,0 +1,227 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p>Describes the status of a cluster while it is in the process of resizing with
+   * an incremental resize.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/DataTransferProgress">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API DataTransferProgress
+  {
+  public:
+    DataTransferProgress();
+    DataTransferProgress(const Aws::Utils::Xml::XmlNode& xmlNode);
+    DataTransferProgress& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    /**
+     * <p>Describes the status of the cluster. While the transfer is in progress the
+     * status is <code>transferringdata</code>.</p>
+     */
+    inline const Aws::String& GetStatus() const{ return m_status; }
+
+    /**
+     * <p>Describes the status of the cluster. While the transfer is in progress the
+     * status is <code>transferringdata</code>.</p>
+     */
+    inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
+
+    /**
+     * <p>Describes the status of the cluster. While the transfer is in progress the
+     * status is <code>transferringdata</code>.</p>
+     */
+    inline void SetStatus(const Aws::String& value) { m_statusHasBeenSet = true; m_status = value; }
+
+    /**
+     * <p>Describes the status of the cluster. While the transfer is in progress the
+     * status is <code>transferringdata</code>.</p>
+     */
+    inline void SetStatus(Aws::String&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }
+
+    /**
+     * <p>Describes the status of the cluster. While the transfer is in progress the
+     * status is <code>transferringdata</code>.</p>
+     */
+    inline void SetStatus(const char* value) { m_statusHasBeenSet = true; m_status.assign(value); }
+
+    /**
+     * <p>Describes the status of the cluster. While the transfer is in progress the
+     * status is <code>transferringdata</code>.</p>
+     */
+    inline DataTransferProgress& WithStatus(const Aws::String& value) { SetStatus(value); return *this;}
+
+    /**
+     * <p>Describes the status of the cluster. While the transfer is in progress the
+     * status is <code>transferringdata</code>.</p>
+     */
+    inline DataTransferProgress& WithStatus(Aws::String&& value) { SetStatus(std::move(value)); return *this;}
+
+    /**
+     * <p>Describes the status of the cluster. While the transfer is in progress the
+     * status is <code>transferringdata</code>.</p>
+     */
+    inline DataTransferProgress& WithStatus(const char* value) { SetStatus(value); return *this;}
+
+
+    /**
+     * <p>Describes the data transfer rate in MB's per second.</p>
+     */
+    inline double GetCurrentRateInMegaBytesPerSecond() const{ return m_currentRateInMegaBytesPerSecond; }
+
+    /**
+     * <p>Describes the data transfer rate in MB's per second.</p>
+     */
+    inline bool CurrentRateInMegaBytesPerSecondHasBeenSet() const { return m_currentRateInMegaBytesPerSecondHasBeenSet; }
+
+    /**
+     * <p>Describes the data transfer rate in MB's per second.</p>
+     */
+    inline void SetCurrentRateInMegaBytesPerSecond(double value) { m_currentRateInMegaBytesPerSecondHasBeenSet = true; m_currentRateInMegaBytesPerSecond = value; }
+
+    /**
+     * <p>Describes the data transfer rate in MB's per second.</p>
+     */
+    inline DataTransferProgress& WithCurrentRateInMegaBytesPerSecond(double value) { SetCurrentRateInMegaBytesPerSecond(value); return *this;}
+
+
+    /**
+     * <p>Describes the total amount of data to be transfered in megabytes.</p>
+     */
+    inline long long GetTotalDataInMegaBytes() const{ return m_totalDataInMegaBytes; }
+
+    /**
+     * <p>Describes the total amount of data to be transfered in megabytes.</p>
+     */
+    inline bool TotalDataInMegaBytesHasBeenSet() const { return m_totalDataInMegaBytesHasBeenSet; }
+
+    /**
+     * <p>Describes the total amount of data to be transfered in megabytes.</p>
+     */
+    inline void SetTotalDataInMegaBytes(long long value) { m_totalDataInMegaBytesHasBeenSet = true; m_totalDataInMegaBytes = value; }
+
+    /**
+     * <p>Describes the total amount of data to be transfered in megabytes.</p>
+     */
+    inline DataTransferProgress& WithTotalDataInMegaBytes(long long value) { SetTotalDataInMegaBytes(value); return *this;}
+
+
+    /**
+     * <p>Describes the total amount of data that has been transfered in MB's.</p>
+     */
+    inline long long GetDataTransferredInMegaBytes() const{ return m_dataTransferredInMegaBytes; }
+
+    /**
+     * <p>Describes the total amount of data that has been transfered in MB's.</p>
+     */
+    inline bool DataTransferredInMegaBytesHasBeenSet() const { return m_dataTransferredInMegaBytesHasBeenSet; }
+
+    /**
+     * <p>Describes the total amount of data that has been transfered in MB's.</p>
+     */
+    inline void SetDataTransferredInMegaBytes(long long value) { m_dataTransferredInMegaBytesHasBeenSet = true; m_dataTransferredInMegaBytes = value; }
+
+    /**
+     * <p>Describes the total amount of data that has been transfered in MB's.</p>
+     */
+    inline DataTransferProgress& WithDataTransferredInMegaBytes(long long value) { SetDataTransferredInMegaBytes(value); return *this;}
+
+
+    /**
+     * <p>Describes the estimated number of seconds remaining to complete the
+     * transfer.</p>
+     */
+    inline long long GetEstimatedTimeToCompletionInSeconds() const{ return m_estimatedTimeToCompletionInSeconds; }
+
+    /**
+     * <p>Describes the estimated number of seconds remaining to complete the
+     * transfer.</p>
+     */
+    inline bool EstimatedTimeToCompletionInSecondsHasBeenSet() const { return m_estimatedTimeToCompletionInSecondsHasBeenSet; }
+
+    /**
+     * <p>Describes the estimated number of seconds remaining to complete the
+     * transfer.</p>
+     */
+    inline void SetEstimatedTimeToCompletionInSeconds(long long value) { m_estimatedTimeToCompletionInSecondsHasBeenSet = true; m_estimatedTimeToCompletionInSeconds = value; }
+
+    /**
+     * <p>Describes the estimated number of seconds remaining to complete the
+     * transfer.</p>
+     */
+    inline DataTransferProgress& WithEstimatedTimeToCompletionInSeconds(long long value) { SetEstimatedTimeToCompletionInSeconds(value); return *this;}
+
+
+    /**
+     * <p>Describes the number of seconds that have elapsed during the data
+     * transfer.</p>
+     */
+    inline long long GetElapsedTimeInSeconds() const{ return m_elapsedTimeInSeconds; }
+
+    /**
+     * <p>Describes the number of seconds that have elapsed during the data
+     * transfer.</p>
+     */
+    inline bool ElapsedTimeInSecondsHasBeenSet() const { return m_elapsedTimeInSecondsHasBeenSet; }
+
+    /**
+     * <p>Describes the number of seconds that have elapsed during the data
+     * transfer.</p>
+     */
+    inline void SetElapsedTimeInSeconds(long long value) { m_elapsedTimeInSecondsHasBeenSet = true; m_elapsedTimeInSeconds = value; }
+
+    /**
+     * <p>Describes the number of seconds that have elapsed during the data
+     * transfer.</p>
+     */
+    inline DataTransferProgress& WithElapsedTimeInSeconds(long long value) { SetElapsedTimeInSeconds(value); return *this;}
+
+  private:
+
+    Aws::String m_status;
+    bool m_statusHasBeenSet;
+
+    double m_currentRateInMegaBytesPerSecond;
+    bool m_currentRateInMegaBytesPerSecondHasBeenSet;
+
+    long long m_totalDataInMegaBytes;
+    bool m_totalDataInMegaBytesHasBeenSet;
+
+    long long m_dataTransferredInMegaBytes;
+    bool m_dataTransferredInMegaBytesHasBeenSet;
+
+    long long m_estimatedTimeToCompletionInSeconds;
+    bool m_estimatedTimeToCompletionInSecondsHasBeenSet;
+
+    long long m_elapsedTimeInSeconds;
+    bool m_elapsedTimeInSecondsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DefaultClusterParameters.h

@@ -0,0 +1,229 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/Parameter.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p>Describes the default cluster parameters for a parameter group
+   * family.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/DefaultClusterParameters">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API DefaultClusterParameters
+  {
+  public:
+    DefaultClusterParameters();
+    DefaultClusterParameters(const Aws::Utils::Xml::XmlNode& xmlNode);
+    DefaultClusterParameters& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    /**
+     * <p>The name of the cluster parameter group family to which the engine default
+     * parameters apply.</p>
+     */
+    inline const Aws::String& GetParameterGroupFamily() const{ return m_parameterGroupFamily; }
+
+    /**
+     * <p>The name of the cluster parameter group family to which the engine default
+     * parameters apply.</p>
+     */
+    inline bool ParameterGroupFamilyHasBeenSet() const { return m_parameterGroupFamilyHasBeenSet; }
+
+    /**
+     * <p>The name of the cluster parameter group family to which the engine default
+     * parameters apply.</p>
+     */
+    inline void SetParameterGroupFamily(const Aws::String& value) { m_parameterGroupFamilyHasBeenSet = true; m_parameterGroupFamily = value; }
+
+    /**
+     * <p>The name of the cluster parameter group family to which the engine default
+     * parameters apply.</p>
+     */
+    inline void SetParameterGroupFamily(Aws::String&& value) { m_parameterGroupFamilyHasBeenSet = true; m_parameterGroupFamily = std::move(value); }
+
+    /**
+     * <p>The name of the cluster parameter group family to which the engine default
+     * parameters apply.</p>
+     */
+    inline void SetParameterGroupFamily(const char* value) { m_parameterGroupFamilyHasBeenSet = true; m_parameterGroupFamily.assign(value); }
+
+    /**
+     * <p>The name of the cluster parameter group family to which the engine default
+     * parameters apply.</p>
+     */
+    inline DefaultClusterParameters& WithParameterGroupFamily(const Aws::String& value) { SetParameterGroupFamily(value); return *this;}
+
+    /**
+     * <p>The name of the cluster parameter group family to which the engine default
+     * parameters apply.</p>
+     */
+    inline DefaultClusterParameters& WithParameterGroupFamily(Aws::String&& value) { SetParameterGroupFamily(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the cluster parameter group family to which the engine default
+     * parameters apply.</p>
+     */
+    inline DefaultClusterParameters& WithParameterGroupFamily(const char* value) { SetParameterGroupFamily(value); return *this;}
+
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline const Aws::String& GetMarker() const{ return m_marker; }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline bool MarkerHasBeenSet() const { return m_markerHasBeenSet; }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline void SetMarker(const Aws::String& value) { m_markerHasBeenSet = true; m_marker = value; }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline void SetMarker(Aws::String&& value) { m_markerHasBeenSet = true; m_marker = std::move(value); }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline void SetMarker(const char* value) { m_markerHasBeenSet = true; m_marker.assign(value); }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline DefaultClusterParameters& WithMarker(const Aws::String& value) { SetMarker(value); return *this;}
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline DefaultClusterParameters& WithMarker(Aws::String&& value) { SetMarker(std::move(value)); return *this;}
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline DefaultClusterParameters& WithMarker(const char* value) { SetMarker(value); return *this;}
+
+
+    /**
+     * <p>The list of cluster default parameters.</p>
+     */
+    inline const Aws::Vector<Parameter>& GetParameters() const{ return m_parameters; }
+
+    /**
+     * <p>The list of cluster default parameters.</p>
+     */
+    inline bool ParametersHasBeenSet() const { return m_parametersHasBeenSet; }
+
+    /**
+     * <p>The list of cluster default parameters.</p>
+     */
+    inline void SetParameters(const Aws::Vector<Parameter>& value) { m_parametersHasBeenSet = true; m_parameters = value; }
+
+    /**
+     * <p>The list of cluster default parameters.</p>
+     */
+    inline void SetParameters(Aws::Vector<Parameter>&& value) { m_parametersHasBeenSet = true; m_parameters = std::move(value); }
+
+    /**
+     * <p>The list of cluster default parameters.</p>
+     */
+    inline DefaultClusterParameters& WithParameters(const Aws::Vector<Parameter>& value) { SetParameters(value); return *this;}
+
+    /**
+     * <p>The list of cluster default parameters.</p>
+     */
+    inline DefaultClusterParameters& WithParameters(Aws::Vector<Parameter>&& value) { SetParameters(std::move(value)); return *this;}
+
+    /**
+     * <p>The list of cluster default parameters.</p>
+     */
+    inline DefaultClusterParameters& AddParameters(const Parameter& value) { m_parametersHasBeenSet = true; m_parameters.push_back(value); return *this; }
+
+    /**
+     * <p>The list of cluster default parameters.</p>
+     */
+    inline DefaultClusterParameters& AddParameters(Parameter&& value) { m_parametersHasBeenSet = true; m_parameters.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_parameterGroupFamily;
+    bool m_parameterGroupFamilyHasBeenSet;
+
+    Aws::String m_marker;
+    bool m_markerHasBeenSet;
+
+    Aws::Vector<Parameter> m_parameters;
+    bool m_parametersHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DeferredMaintenanceWindow.h

@@ -0,0 +1,165 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/DateTime.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p>Describes a deferred maintenance window</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/DeferredMaintenanceWindow">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API DeferredMaintenanceWindow
+  {
+  public:
+    DeferredMaintenanceWindow();
+    DeferredMaintenanceWindow(const Aws::Utils::Xml::XmlNode& xmlNode);
+    DeferredMaintenanceWindow& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    /**
+     * <p>A unique identifier for the maintenance window.</p>
+     */
+    inline const Aws::String& GetDeferMaintenanceIdentifier() const{ return m_deferMaintenanceIdentifier; }
+
+    /**
+     * <p>A unique identifier for the maintenance window.</p>
+     */
+    inline bool DeferMaintenanceIdentifierHasBeenSet() const { return m_deferMaintenanceIdentifierHasBeenSet; }
+
+    /**
+     * <p>A unique identifier for the maintenance window.</p>
+     */
+    inline void SetDeferMaintenanceIdentifier(const Aws::String& value) { m_deferMaintenanceIdentifierHasBeenSet = true; m_deferMaintenanceIdentifier = value; }
+
+    /**
+     * <p>A unique identifier for the maintenance window.</p>
+     */
+    inline void SetDeferMaintenanceIdentifier(Aws::String&& value) { m_deferMaintenanceIdentifierHasBeenSet = true; m_deferMaintenanceIdentifier = std::move(value); }
+
+    /**
+     * <p>A unique identifier for the maintenance window.</p>
+     */
+    inline void SetDeferMaintenanceIdentifier(const char* value) { m_deferMaintenanceIdentifierHasBeenSet = true; m_deferMaintenanceIdentifier.assign(value); }
+
+    /**
+     * <p>A unique identifier for the maintenance window.</p>
+     */
+    inline DeferredMaintenanceWindow& WithDeferMaintenanceIdentifier(const Aws::String& value) { SetDeferMaintenanceIdentifier(value); return *this;}
+
+    /**
+     * <p>A unique identifier for the maintenance window.</p>
+     */
+    inline DeferredMaintenanceWindow& WithDeferMaintenanceIdentifier(Aws::String&& value) { SetDeferMaintenanceIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>A unique identifier for the maintenance window.</p>
+     */
+    inline DeferredMaintenanceWindow& WithDeferMaintenanceIdentifier(const char* value) { SetDeferMaintenanceIdentifier(value); return *this;}
+
+
+    /**
+     * <p> A timestamp for the beginning of the time period when we defer
+     * maintenance.</p>
+     */
+    inline const Aws::Utils::DateTime& GetDeferMaintenanceStartTime() const{ return m_deferMaintenanceStartTime; }
+
+    /**
+     * <p> A timestamp for the beginning of the time period when we defer
+     * maintenance.</p>
+     */
+    inline bool DeferMaintenanceStartTimeHasBeenSet() const { return m_deferMaintenanceStartTimeHasBeenSet; }
+
+    /**
+     * <p> A timestamp for the beginning of the time period when we defer
+     * maintenance.</p>
+     */
+    inline void SetDeferMaintenanceStartTime(const Aws::Utils::DateTime& value) { m_deferMaintenanceStartTimeHasBeenSet = true; m_deferMaintenanceStartTime = value; }
+
+    /**
+     * <p> A timestamp for the beginning of the time period when we defer
+     * maintenance.</p>
+     */
+    inline void SetDeferMaintenanceStartTime(Aws::Utils::DateTime&& value) { m_deferMaintenanceStartTimeHasBeenSet = true; m_deferMaintenanceStartTime = std::move(value); }
+
+    /**
+     * <p> A timestamp for the beginning of the time period when we defer
+     * maintenance.</p>
+     */
+    inline DeferredMaintenanceWindow& WithDeferMaintenanceStartTime(const Aws::Utils::DateTime& value) { SetDeferMaintenanceStartTime(value); return *this;}
+
+    /**
+     * <p> A timestamp for the beginning of the time period when we defer
+     * maintenance.</p>
+     */
+    inline DeferredMaintenanceWindow& WithDeferMaintenanceStartTime(Aws::Utils::DateTime&& value) { SetDeferMaintenanceStartTime(std::move(value)); return *this;}
+
+
+    /**
+     * <p> A timestamp for the end of the time period when we defer maintenance.</p>
+     */
+    inline const Aws::Utils::DateTime& GetDeferMaintenanceEndTime() const{ return m_deferMaintenanceEndTime; }
+
+    /**
+     * <p> A timestamp for the end of the time period when we defer maintenance.</p>
+     */
+    inline bool DeferMaintenanceEndTimeHasBeenSet() const { return m_deferMaintenanceEndTimeHasBeenSet; }
+
+    /**
+     * <p> A timestamp for the end of the time period when we defer maintenance.</p>
+     */
+    inline void SetDeferMaintenanceEndTime(const Aws::Utils::DateTime& value) { m_deferMaintenanceEndTimeHasBeenSet = true; m_deferMaintenanceEndTime = value; }
+
+    /**
+     * <p> A timestamp for the end of the time period when we defer maintenance.</p>
+     */
+    inline void SetDeferMaintenanceEndTime(Aws::Utils::DateTime&& value) { m_deferMaintenanceEndTimeHasBeenSet = true; m_deferMaintenanceEndTime = std::move(value); }
+
+    /**
+     * <p> A timestamp for the end of the time period when we defer maintenance.</p>
+     */
+    inline DeferredMaintenanceWindow& WithDeferMaintenanceEndTime(const Aws::Utils::DateTime& value) { SetDeferMaintenanceEndTime(value); return *this;}
+
+    /**
+     * <p> A timestamp for the end of the time period when we defer maintenance.</p>
+     */
+    inline DeferredMaintenanceWindow& WithDeferMaintenanceEndTime(Aws::Utils::DateTime&& value) { SetDeferMaintenanceEndTime(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_deferMaintenanceIdentifier;
+    bool m_deferMaintenanceIdentifierHasBeenSet;
+
+    Aws::Utils::DateTime m_deferMaintenanceStartTime;
+    bool m_deferMaintenanceStartTimeHasBeenSet;
+
+    Aws::Utils::DateTime m_deferMaintenanceEndTime;
+    bool m_deferMaintenanceEndTimeHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DeleteClusterParameterGroupRequest.h

@@ -0,0 +1,106 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p/><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/DeleteClusterParameterGroupMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API DeleteClusterParameterGroupRequest : public RedshiftRequest
+  {
+  public:
+    DeleteClusterParameterGroupRequest();
+
+    // 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 "DeleteClusterParameterGroup"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The name of the parameter group to be deleted.</p> <p>Constraints:</p> <ul>
+     * <li> <p>Must be the name of an existing cluster parameter group.</p> </li> <li>
+     * <p>Cannot delete a default cluster parameter group.</p> </li> </ul>
+     */
+    inline const Aws::String& GetParameterGroupName() const{ return m_parameterGroupName; }
+
+    /**
+     * <p>The name of the parameter group to be deleted.</p> <p>Constraints:</p> <ul>
+     * <li> <p>Must be the name of an existing cluster parameter group.</p> </li> <li>
+     * <p>Cannot delete a default cluster parameter group.</p> </li> </ul>
+     */
+    inline bool ParameterGroupNameHasBeenSet() const { return m_parameterGroupNameHasBeenSet; }
+
+    /**
+     * <p>The name of the parameter group to be deleted.</p> <p>Constraints:</p> <ul>
+     * <li> <p>Must be the name of an existing cluster parameter group.</p> </li> <li>
+     * <p>Cannot delete a default cluster parameter group.</p> </li> </ul>
+     */
+    inline void SetParameterGroupName(const Aws::String& value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName = value; }
+
+    /**
+     * <p>The name of the parameter group to be deleted.</p> <p>Constraints:</p> <ul>
+     * <li> <p>Must be the name of an existing cluster parameter group.</p> </li> <li>
+     * <p>Cannot delete a default cluster parameter group.</p> </li> </ul>
+     */
+    inline void SetParameterGroupName(Aws::String&& value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName = std::move(value); }
+
+    /**
+     * <p>The name of the parameter group to be deleted.</p> <p>Constraints:</p> <ul>
+     * <li> <p>Must be the name of an existing cluster parameter group.</p> </li> <li>
+     * <p>Cannot delete a default cluster parameter group.</p> </li> </ul>
+     */
+    inline void SetParameterGroupName(const char* value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName.assign(value); }
+
+    /**
+     * <p>The name of the parameter group to be deleted.</p> <p>Constraints:</p> <ul>
+     * <li> <p>Must be the name of an existing cluster parameter group.</p> </li> <li>
+     * <p>Cannot delete a default cluster parameter group.</p> </li> </ul>
+     */
+    inline DeleteClusterParameterGroupRequest& WithParameterGroupName(const Aws::String& value) { SetParameterGroupName(value); return *this;}
+
+    /**
+     * <p>The name of the parameter group to be deleted.</p> <p>Constraints:</p> <ul>
+     * <li> <p>Must be the name of an existing cluster parameter group.</p> </li> <li>
+     * <p>Cannot delete a default cluster parameter group.</p> </li> </ul>
+     */
+    inline DeleteClusterParameterGroupRequest& WithParameterGroupName(Aws::String&& value) { SetParameterGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the parameter group to be deleted.</p> <p>Constraints:</p> <ul>
+     * <li> <p>Must be the name of an existing cluster parameter group.</p> </li> <li>
+     * <p>Cannot delete a default cluster parameter group.</p> </li> </ul>
+     */
+    inline DeleteClusterParameterGroupRequest& WithParameterGroupName(const char* value) { SetParameterGroupName(value); return *this;}
+
+  private:
+
+    Aws::String m_parameterGroupName;
+    bool m_parameterGroupNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DeleteClusterRequest.h

@@ -0,0 +1,282 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p/><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/DeleteClusterMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API DeleteClusterRequest : public RedshiftRequest
+  {
+  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;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The identifier of the cluster to be deleted.</p> <p>Constraints:</p> <ul>
+     * <li> <p>Must contain lowercase characters.</p> </li> <li> <p>Must contain from 1
+     * to 63 alphanumeric characters or hyphens.</p> </li> <li> <p>First character must
+     * be a letter.</p> </li> <li> <p>Cannot end with a hyphen or contain two
+     * consecutive hyphens.</p> </li> </ul>
+     */
+    inline const Aws::String& GetClusterIdentifier() const{ return m_clusterIdentifier; }
+
+    /**
+     * <p>The identifier of the cluster to be deleted.</p> <p>Constraints:</p> <ul>
+     * <li> <p>Must contain lowercase characters.</p> </li> <li> <p>Must contain from 1
+     * to 63 alphanumeric characters or hyphens.</p> </li> <li> <p>First character must
+     * be a letter.</p> </li> <li> <p>Cannot end with a hyphen or contain two
+     * consecutive hyphens.</p> </li> </ul>
+     */
+    inline bool ClusterIdentifierHasBeenSet() const { return m_clusterIdentifierHasBeenSet; }
+
+    /**
+     * <p>The identifier of the cluster to be deleted.</p> <p>Constraints:</p> <ul>
+     * <li> <p>Must contain lowercase characters.</p> </li> <li> <p>Must contain from 1
+     * to 63 alphanumeric characters or hyphens.</p> </li> <li> <p>First character must
+     * be a letter.</p> </li> <li> <p>Cannot end with a hyphen or contain two
+     * consecutive hyphens.</p> </li> </ul>
+     */
+    inline void SetClusterIdentifier(const Aws::String& value) { m_clusterIdentifierHasBeenSet = true; m_clusterIdentifier = value; }
+
+    /**
+     * <p>The identifier of the cluster to be deleted.</p> <p>Constraints:</p> <ul>
+     * <li> <p>Must contain lowercase characters.</p> </li> <li> <p>Must contain from 1
+     * to 63 alphanumeric characters or hyphens.</p> </li> <li> <p>First character must
+     * be a letter.</p> </li> <li> <p>Cannot end with a hyphen or contain two
+     * consecutive hyphens.</p> </li> </ul>
+     */
+    inline void SetClusterIdentifier(Aws::String&& value) { m_clusterIdentifierHasBeenSet = true; m_clusterIdentifier = std::move(value); }
+
+    /**
+     * <p>The identifier of the cluster to be deleted.</p> <p>Constraints:</p> <ul>
+     * <li> <p>Must contain lowercase characters.</p> </li> <li> <p>Must contain from 1
+     * to 63 alphanumeric characters or hyphens.</p> </li> <li> <p>First character must
+     * be a letter.</p> </li> <li> <p>Cannot end with a hyphen or contain two
+     * consecutive hyphens.</p> </li> </ul>
+     */
+    inline void SetClusterIdentifier(const char* value) { m_clusterIdentifierHasBeenSet = true; m_clusterIdentifier.assign(value); }
+
+    /**
+     * <p>The identifier of the cluster to be deleted.</p> <p>Constraints:</p> <ul>
+     * <li> <p>Must contain lowercase characters.</p> </li> <li> <p>Must contain from 1
+     * to 63 alphanumeric characters or hyphens.</p> </li> <li> <p>First character must
+     * be a letter.</p> </li> <li> <p>Cannot end with a hyphen or contain two
+     * consecutive hyphens.</p> </li> </ul>
+     */
+    inline DeleteClusterRequest& WithClusterIdentifier(const Aws::String& value) { SetClusterIdentifier(value); return *this;}
+
+    /**
+     * <p>The identifier of the cluster to be deleted.</p> <p>Constraints:</p> <ul>
+     * <li> <p>Must contain lowercase characters.</p> </li> <li> <p>Must contain from 1
+     * to 63 alphanumeric characters or hyphens.</p> </li> <li> <p>First character must
+     * be a letter.</p> </li> <li> <p>Cannot end with a hyphen or contain two
+     * consecutive hyphens.</p> </li> </ul>
+     */
+    inline DeleteClusterRequest& WithClusterIdentifier(Aws::String&& value) { SetClusterIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>The identifier of the cluster to be deleted.</p> <p>Constraints:</p> <ul>
+     * <li> <p>Must contain lowercase characters.</p> </li> <li> <p>Must contain from 1
+     * to 63 alphanumeric characters or hyphens.</p> </li> <li> <p>First character must
+     * be a letter.</p> </li> <li> <p>Cannot end with a hyphen or contain two
+     * consecutive hyphens.</p> </li> </ul>
+     */
+    inline DeleteClusterRequest& WithClusterIdentifier(const char* value) { SetClusterIdentifier(value); return *this;}
+
+
+    /**
+     * <p>Determines whether a final snapshot of the cluster is created before Amazon
+     * Redshift deletes the cluster. If <code>true</code>, a final cluster snapshot is
+     * not created. If <code>false</code>, a final cluster snapshot is created before
+     * the cluster is deleted. </p>  <p>The <i>FinalClusterSnapshotIdentifier</i>
+     * parameter must be specified if <i>SkipFinalClusterSnapshot</i> is
+     * <code>false</code>.</p>  <p>Default: <code>false</code> </p>
+     */
+    inline bool GetSkipFinalClusterSnapshot() const{ return m_skipFinalClusterSnapshot; }
+
+    /**
+     * <p>Determines whether a final snapshot of the cluster is created before Amazon
+     * Redshift deletes the cluster. If <code>true</code>, a final cluster snapshot is
+     * not created. If <code>false</code>, a final cluster snapshot is created before
+     * the cluster is deleted. </p>  <p>The <i>FinalClusterSnapshotIdentifier</i>
+     * parameter must be specified if <i>SkipFinalClusterSnapshot</i> is
+     * <code>false</code>.</p>  <p>Default: <code>false</code> </p>
+     */
+    inline bool SkipFinalClusterSnapshotHasBeenSet() const { return m_skipFinalClusterSnapshotHasBeenSet; }
+
+    /**
+     * <p>Determines whether a final snapshot of the cluster is created before Amazon
+     * Redshift deletes the cluster. If <code>true</code>, a final cluster snapshot is
+     * not created. If <code>false</code>, a final cluster snapshot is created before
+     * the cluster is deleted. </p>  <p>The <i>FinalClusterSnapshotIdentifier</i>
+     * parameter must be specified if <i>SkipFinalClusterSnapshot</i> is
+     * <code>false</code>.</p>  <p>Default: <code>false</code> </p>
+     */
+    inline void SetSkipFinalClusterSnapshot(bool value) { m_skipFinalClusterSnapshotHasBeenSet = true; m_skipFinalClusterSnapshot = value; }
+
+    /**
+     * <p>Determines whether a final snapshot of the cluster is created before Amazon
+     * Redshift deletes the cluster. If <code>true</code>, a final cluster snapshot is
+     * not created. If <code>false</code>, a final cluster snapshot is created before
+     * the cluster is deleted. </p>  <p>The <i>FinalClusterSnapshotIdentifier</i>
+     * parameter must be specified if <i>SkipFinalClusterSnapshot</i> is
+     * <code>false</code>.</p>  <p>Default: <code>false</code> </p>
+     */
+    inline DeleteClusterRequest& WithSkipFinalClusterSnapshot(bool value) { SetSkipFinalClusterSnapshot(value); return *this;}
+
+
+    /**
+     * <p>The identifier of the final snapshot that is to be created immediately before
+     * deleting the cluster. If this parameter is provided,
+     * <i>SkipFinalClusterSnapshot</i> must be <code>false</code>. </p>
+     * <p>Constraints:</p> <ul> <li> <p>Must be 1 to 255 alphanumeric characters.</p>
+     * </li> <li> <p>First character must be a letter.</p> </li> <li> <p>Cannot end
+     * with a hyphen or contain two consecutive hyphens.</p> </li> </ul>
+     */
+    inline const Aws::String& GetFinalClusterSnapshotIdentifier() const{ return m_finalClusterSnapshotIdentifier; }
+
+    /**
+     * <p>The identifier of the final snapshot that is to be created immediately before
+     * deleting the cluster. If this parameter is provided,
+     * <i>SkipFinalClusterSnapshot</i> must be <code>false</code>. </p>
+     * <p>Constraints:</p> <ul> <li> <p>Must be 1 to 255 alphanumeric characters.</p>
+     * </li> <li> <p>First character must be a letter.</p> </li> <li> <p>Cannot end
+     * with a hyphen or contain two consecutive hyphens.</p> </li> </ul>
+     */
+    inline bool FinalClusterSnapshotIdentifierHasBeenSet() const { return m_finalClusterSnapshotIdentifierHasBeenSet; }
+
+    /**
+     * <p>The identifier of the final snapshot that is to be created immediately before
+     * deleting the cluster. If this parameter is provided,
+     * <i>SkipFinalClusterSnapshot</i> must be <code>false</code>. </p>
+     * <p>Constraints:</p> <ul> <li> <p>Must be 1 to 255 alphanumeric characters.</p>
+     * </li> <li> <p>First character must be a letter.</p> </li> <li> <p>Cannot end
+     * with a hyphen or contain two consecutive hyphens.</p> </li> </ul>
+     */
+    inline void SetFinalClusterSnapshotIdentifier(const Aws::String& value) { m_finalClusterSnapshotIdentifierHasBeenSet = true; m_finalClusterSnapshotIdentifier = value; }
+
+    /**
+     * <p>The identifier of the final snapshot that is to be created immediately before
+     * deleting the cluster. If this parameter is provided,
+     * <i>SkipFinalClusterSnapshot</i> must be <code>false</code>. </p>
+     * <p>Constraints:</p> <ul> <li> <p>Must be 1 to 255 alphanumeric characters.</p>
+     * </li> <li> <p>First character must be a letter.</p> </li> <li> <p>Cannot end
+     * with a hyphen or contain two consecutive hyphens.</p> </li> </ul>
+     */
+    inline void SetFinalClusterSnapshotIdentifier(Aws::String&& value) { m_finalClusterSnapshotIdentifierHasBeenSet = true; m_finalClusterSnapshotIdentifier = std::move(value); }
+
+    /**
+     * <p>The identifier of the final snapshot that is to be created immediately before
+     * deleting the cluster. If this parameter is provided,
+     * <i>SkipFinalClusterSnapshot</i> must be <code>false</code>. </p>
+     * <p>Constraints:</p> <ul> <li> <p>Must be 1 to 255 alphanumeric characters.</p>
+     * </li> <li> <p>First character must be a letter.</p> </li> <li> <p>Cannot end
+     * with a hyphen or contain two consecutive hyphens.</p> </li> </ul>
+     */
+    inline void SetFinalClusterSnapshotIdentifier(const char* value) { m_finalClusterSnapshotIdentifierHasBeenSet = true; m_finalClusterSnapshotIdentifier.assign(value); }
+
+    /**
+     * <p>The identifier of the final snapshot that is to be created immediately before
+     * deleting the cluster. If this parameter is provided,
+     * <i>SkipFinalClusterSnapshot</i> must be <code>false</code>. </p>
+     * <p>Constraints:</p> <ul> <li> <p>Must be 1 to 255 alphanumeric characters.</p>
+     * </li> <li> <p>First character must be a letter.</p> </li> <li> <p>Cannot end
+     * with a hyphen or contain two consecutive hyphens.</p> </li> </ul>
+     */
+    inline DeleteClusterRequest& WithFinalClusterSnapshotIdentifier(const Aws::String& value) { SetFinalClusterSnapshotIdentifier(value); return *this;}
+
+    /**
+     * <p>The identifier of the final snapshot that is to be created immediately before
+     * deleting the cluster. If this parameter is provided,
+     * <i>SkipFinalClusterSnapshot</i> must be <code>false</code>. </p>
+     * <p>Constraints:</p> <ul> <li> <p>Must be 1 to 255 alphanumeric characters.</p>
+     * </li> <li> <p>First character must be a letter.</p> </li> <li> <p>Cannot end
+     * with a hyphen or contain two consecutive hyphens.</p> </li> </ul>
+     */
+    inline DeleteClusterRequest& WithFinalClusterSnapshotIdentifier(Aws::String&& value) { SetFinalClusterSnapshotIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>The identifier of the final snapshot that is to be created immediately before
+     * deleting the cluster. If this parameter is provided,
+     * <i>SkipFinalClusterSnapshot</i> must be <code>false</code>. </p>
+     * <p>Constraints:</p> <ul> <li> <p>Must be 1 to 255 alphanumeric characters.</p>
+     * </li> <li> <p>First character must be a letter.</p> </li> <li> <p>Cannot end
+     * with a hyphen or contain two consecutive hyphens.</p> </li> </ul>
+     */
+    inline DeleteClusterRequest& WithFinalClusterSnapshotIdentifier(const char* value) { SetFinalClusterSnapshotIdentifier(value); return *this;}
+
+
+    /**
+     * <p>The number of days that a manual snapshot is retained. If the value is -1,
+     * the manual snapshot is retained indefinitely.</p> <p>The value must be either -1
+     * or an integer between 1 and 3,653.</p> <p>The default value is -1.</p>
+     */
+    inline int GetFinalClusterSnapshotRetentionPeriod() const{ return m_finalClusterSnapshotRetentionPeriod; }
+
+    /**
+     * <p>The number of days that a manual snapshot is retained. If the value is -1,
+     * the manual snapshot is retained indefinitely.</p> <p>The value must be either -1
+     * or an integer between 1 and 3,653.</p> <p>The default value is -1.</p>
+     */
+    inline bool FinalClusterSnapshotRetentionPeriodHasBeenSet() const { return m_finalClusterSnapshotRetentionPeriodHasBeenSet; }
+
+    /**
+     * <p>The number of days that a manual snapshot is retained. If the value is -1,
+     * the manual snapshot is retained indefinitely.</p> <p>The value must be either -1
+     * or an integer between 1 and 3,653.</p> <p>The default value is -1.</p>
+     */
+    inline void SetFinalClusterSnapshotRetentionPeriod(int value) { m_finalClusterSnapshotRetentionPeriodHasBeenSet = true; m_finalClusterSnapshotRetentionPeriod = value; }
+
+    /**
+     * <p>The number of days that a manual snapshot is retained. If the value is -1,
+     * the manual snapshot is retained indefinitely.</p> <p>The value must be either -1
+     * or an integer between 1 and 3,653.</p> <p>The default value is -1.</p>
+     */
+    inline DeleteClusterRequest& WithFinalClusterSnapshotRetentionPeriod(int value) { SetFinalClusterSnapshotRetentionPeriod(value); return *this;}
+
+  private:
+
+    Aws::String m_clusterIdentifier;
+    bool m_clusterIdentifierHasBeenSet;
+
+    bool m_skipFinalClusterSnapshot;
+    bool m_skipFinalClusterSnapshotHasBeenSet;
+
+    Aws::String m_finalClusterSnapshotIdentifier;
+    bool m_finalClusterSnapshotIdentifierHasBeenSet;
+
+    int m_finalClusterSnapshotRetentionPeriod;
+    bool m_finalClusterSnapshotRetentionPeriodHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

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

@@ -0,0 +1,76 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/model/Cluster.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  class AWS_REDSHIFT_API DeleteClusterResult
+  {
+  public:
+    DeleteClusterResult();
+    DeleteClusterResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    DeleteClusterResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    
+    inline const Cluster& GetCluster() const{ return m_cluster; }
+
+    
+    inline void SetCluster(const Cluster& value) { m_cluster = value; }
+
+    
+    inline void SetCluster(Cluster&& value) { m_cluster = std::move(value); }
+
+    
+    inline DeleteClusterResult& WithCluster(const Cluster& value) { SetCluster(value); return *this;}
+
+    
+    inline DeleteClusterResult& WithCluster(Cluster&& value) { SetCluster(std::move(value)); return *this;}
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline DeleteClusterResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline DeleteClusterResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    Cluster m_cluster;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DeleteClusterSecurityGroupRequest.h

@@ -0,0 +1,90 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p/><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/DeleteClusterSecurityGroupMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API DeleteClusterSecurityGroupRequest : public RedshiftRequest
+  {
+  public:
+    DeleteClusterSecurityGroupRequest();
+
+    // 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 "DeleteClusterSecurityGroup"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The name of the cluster security group to be deleted.</p>
+     */
+    inline const Aws::String& GetClusterSecurityGroupName() const{ return m_clusterSecurityGroupName; }
+
+    /**
+     * <p>The name of the cluster security group to be deleted.</p>
+     */
+    inline bool ClusterSecurityGroupNameHasBeenSet() const { return m_clusterSecurityGroupNameHasBeenSet; }
+
+    /**
+     * <p>The name of the cluster security group to be deleted.</p>
+     */
+    inline void SetClusterSecurityGroupName(const Aws::String& value) { m_clusterSecurityGroupNameHasBeenSet = true; m_clusterSecurityGroupName = value; }
+
+    /**
+     * <p>The name of the cluster security group to be deleted.</p>
+     */
+    inline void SetClusterSecurityGroupName(Aws::String&& value) { m_clusterSecurityGroupNameHasBeenSet = true; m_clusterSecurityGroupName = std::move(value); }
+
+    /**
+     * <p>The name of the cluster security group to be deleted.</p>
+     */
+    inline void SetClusterSecurityGroupName(const char* value) { m_clusterSecurityGroupNameHasBeenSet = true; m_clusterSecurityGroupName.assign(value); }
+
+    /**
+     * <p>The name of the cluster security group to be deleted.</p>
+     */
+    inline DeleteClusterSecurityGroupRequest& WithClusterSecurityGroupName(const Aws::String& value) { SetClusterSecurityGroupName(value); return *this;}
+
+    /**
+     * <p>The name of the cluster security group to be deleted.</p>
+     */
+    inline DeleteClusterSecurityGroupRequest& WithClusterSecurityGroupName(Aws::String&& value) { SetClusterSecurityGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the cluster security group to be deleted.</p>
+     */
+    inline DeleteClusterSecurityGroupRequest& WithClusterSecurityGroupName(const char* value) { SetClusterSecurityGroupName(value); return *this;}
+
+  private:
+
+    Aws::String m_clusterSecurityGroupName;
+    bool m_clusterSecurityGroupNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DeleteClusterSnapshotMessage.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/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p/><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/DeleteClusterSnapshotMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API DeleteClusterSnapshotMessage
+  {
+  public:
+    DeleteClusterSnapshotMessage();
+    DeleteClusterSnapshotMessage(const Aws::Utils::Xml::XmlNode& xmlNode);
+    DeleteClusterSnapshotMessage& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    /**
+     * <p>The unique identifier of the manual snapshot to be deleted.</p>
+     * <p>Constraints: Must be the name of an existing snapshot that is in the
+     * <code>available</code>, <code>failed</code>, or <code>cancelled</code>
+     * state.</p>
+     */
+    inline const Aws::String& GetSnapshotIdentifier() const{ return m_snapshotIdentifier; }
+
+    /**
+     * <p>The unique identifier of the manual snapshot to be deleted.</p>
+     * <p>Constraints: Must be the name of an existing snapshot that is in the
+     * <code>available</code>, <code>failed</code>, or <code>cancelled</code>
+     * state.</p>
+     */
+    inline bool SnapshotIdentifierHasBeenSet() const { return m_snapshotIdentifierHasBeenSet; }
+
+    /**
+     * <p>The unique identifier of the manual snapshot to be deleted.</p>
+     * <p>Constraints: Must be the name of an existing snapshot that is in the
+     * <code>available</code>, <code>failed</code>, or <code>cancelled</code>
+     * state.</p>
+     */
+    inline void SetSnapshotIdentifier(const Aws::String& value) { m_snapshotIdentifierHasBeenSet = true; m_snapshotIdentifier = value; }
+
+    /**
+     * <p>The unique identifier of the manual snapshot to be deleted.</p>
+     * <p>Constraints: Must be the name of an existing snapshot that is in the
+     * <code>available</code>, <code>failed</code>, or <code>cancelled</code>
+     * state.</p>
+     */
+    inline void SetSnapshotIdentifier(Aws::String&& value) { m_snapshotIdentifierHasBeenSet = true; m_snapshotIdentifier = std::move(value); }
+
+    /**
+     * <p>The unique identifier of the manual snapshot to be deleted.</p>
+     * <p>Constraints: Must be the name of an existing snapshot that is in the
+     * <code>available</code>, <code>failed</code>, or <code>cancelled</code>
+     * state.</p>
+     */
+    inline void SetSnapshotIdentifier(const char* value) { m_snapshotIdentifierHasBeenSet = true; m_snapshotIdentifier.assign(value); }
+
+    /**
+     * <p>The unique identifier of the manual snapshot to be deleted.</p>
+     * <p>Constraints: Must be the name of an existing snapshot that is in the
+     * <code>available</code>, <code>failed</code>, or <code>cancelled</code>
+     * state.</p>
+     */
+    inline DeleteClusterSnapshotMessage& WithSnapshotIdentifier(const Aws::String& value) { SetSnapshotIdentifier(value); return *this;}
+
+    /**
+     * <p>The unique identifier of the manual snapshot to be deleted.</p>
+     * <p>Constraints: Must be the name of an existing snapshot that is in the
+     * <code>available</code>, <code>failed</code>, or <code>cancelled</code>
+     * state.</p>
+     */
+    inline DeleteClusterSnapshotMessage& WithSnapshotIdentifier(Aws::String&& value) { SetSnapshotIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>The unique identifier of the manual snapshot to be deleted.</p>
+     * <p>Constraints: Must be the name of an existing snapshot that is in the
+     * <code>available</code>, <code>failed</code>, or <code>cancelled</code>
+     * state.</p>
+     */
+    inline DeleteClusterSnapshotMessage& WithSnapshotIdentifier(const char* value) { SetSnapshotIdentifier(value); return *this;}
+
+
+    /**
+     * <p>The unique identifier of the cluster the snapshot was created from. This
+     * parameter is required if your IAM user has a policy containing a snapshot
+     * resource element that specifies anything other than * for the cluster name.</p>
+     * <p>Constraints: Must be the name of valid cluster.</p>
+     */
+    inline const Aws::String& GetSnapshotClusterIdentifier() const{ return m_snapshotClusterIdentifier; }
+
+    /**
+     * <p>The unique identifier of the cluster the snapshot was created from. This
+     * parameter is required if your IAM user has a policy containing a snapshot
+     * resource element that specifies anything other than * for the cluster name.</p>
+     * <p>Constraints: Must be the name of valid cluster.</p>
+     */
+    inline bool SnapshotClusterIdentifierHasBeenSet() const { return m_snapshotClusterIdentifierHasBeenSet; }
+
+    /**
+     * <p>The unique identifier of the cluster the snapshot was created from. This
+     * parameter is required if your IAM user has a policy containing a snapshot
+     * resource element that specifies anything other than * for the cluster name.</p>
+     * <p>Constraints: Must be the name of valid cluster.</p>
+     */
+    inline void SetSnapshotClusterIdentifier(const Aws::String& value) { m_snapshotClusterIdentifierHasBeenSet = true; m_snapshotClusterIdentifier = value; }
+
+    /**
+     * <p>The unique identifier of the cluster the snapshot was created from. This
+     * parameter is required if your IAM user has a policy containing a snapshot
+     * resource element that specifies anything other than * for the cluster name.</p>
+     * <p>Constraints: Must be the name of valid cluster.</p>
+     */
+    inline void SetSnapshotClusterIdentifier(Aws::String&& value) { m_snapshotClusterIdentifierHasBeenSet = true; m_snapshotClusterIdentifier = std::move(value); }
+
+    /**
+     * <p>The unique identifier of the cluster the snapshot was created from. This
+     * parameter is required if your IAM user has a policy containing a snapshot
+     * resource element that specifies anything other than * for the cluster name.</p>
+     * <p>Constraints: Must be the name of valid cluster.</p>
+     */
+    inline void SetSnapshotClusterIdentifier(const char* value) { m_snapshotClusterIdentifierHasBeenSet = true; m_snapshotClusterIdentifier.assign(value); }
+
+    /**
+     * <p>The unique identifier of the cluster the snapshot was created from. This
+     * parameter is required if your IAM user has a policy containing a snapshot
+     * resource element that specifies anything other than * for the cluster name.</p>
+     * <p>Constraints: Must be the name of valid cluster.</p>
+     */
+    inline DeleteClusterSnapshotMessage& WithSnapshotClusterIdentifier(const Aws::String& value) { SetSnapshotClusterIdentifier(value); return *this;}
+
+    /**
+     * <p>The unique identifier of the cluster the snapshot was created from. This
+     * parameter is required if your IAM user has a policy containing a snapshot
+     * resource element that specifies anything other than * for the cluster name.</p>
+     * <p>Constraints: Must be the name of valid cluster.</p>
+     */
+    inline DeleteClusterSnapshotMessage& WithSnapshotClusterIdentifier(Aws::String&& value) { SetSnapshotClusterIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>The unique identifier of the cluster the snapshot was created from. This
+     * parameter is required if your IAM user has a policy containing a snapshot
+     * resource element that specifies anything other than * for the cluster name.</p>
+     * <p>Constraints: Must be the name of valid cluster.</p>
+     */
+    inline DeleteClusterSnapshotMessage& WithSnapshotClusterIdentifier(const char* value) { SetSnapshotClusterIdentifier(value); return *this;}
+
+  private:
+
+    Aws::String m_snapshotIdentifier;
+    bool m_snapshotIdentifierHasBeenSet;
+
+    Aws::String m_snapshotClusterIdentifier;
+    bool m_snapshotClusterIdentifierHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DeleteClusterSnapshotRequest.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/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p/><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/DeleteClusterSnapshotMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API DeleteClusterSnapshotRequest : public RedshiftRequest
+  {
+  public:
+    DeleteClusterSnapshotRequest();
+
+    // 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 "DeleteClusterSnapshot"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The unique identifier of the manual snapshot to be deleted.</p>
+     * <p>Constraints: Must be the name of an existing snapshot that is in the
+     * <code>available</code>, <code>failed</code>, or <code>cancelled</code>
+     * state.</p>
+     */
+    inline const Aws::String& GetSnapshotIdentifier() const{ return m_snapshotIdentifier; }
+
+    /**
+     * <p>The unique identifier of the manual snapshot to be deleted.</p>
+     * <p>Constraints: Must be the name of an existing snapshot that is in the
+     * <code>available</code>, <code>failed</code>, or <code>cancelled</code>
+     * state.</p>
+     */
+    inline bool SnapshotIdentifierHasBeenSet() const { return m_snapshotIdentifierHasBeenSet; }
+
+    /**
+     * <p>The unique identifier of the manual snapshot to be deleted.</p>
+     * <p>Constraints: Must be the name of an existing snapshot that is in the
+     * <code>available</code>, <code>failed</code>, or <code>cancelled</code>
+     * state.</p>
+     */
+    inline void SetSnapshotIdentifier(const Aws::String& value) { m_snapshotIdentifierHasBeenSet = true; m_snapshotIdentifier = value; }
+
+    /**
+     * <p>The unique identifier of the manual snapshot to be deleted.</p>
+     * <p>Constraints: Must be the name of an existing snapshot that is in the
+     * <code>available</code>, <code>failed</code>, or <code>cancelled</code>
+     * state.</p>
+     */
+    inline void SetSnapshotIdentifier(Aws::String&& value) { m_snapshotIdentifierHasBeenSet = true; m_snapshotIdentifier = std::move(value); }
+
+    /**
+     * <p>The unique identifier of the manual snapshot to be deleted.</p>
+     * <p>Constraints: Must be the name of an existing snapshot that is in the
+     * <code>available</code>, <code>failed</code>, or <code>cancelled</code>
+     * state.</p>
+     */
+    inline void SetSnapshotIdentifier(const char* value) { m_snapshotIdentifierHasBeenSet = true; m_snapshotIdentifier.assign(value); }
+
+    /**
+     * <p>The unique identifier of the manual snapshot to be deleted.</p>
+     * <p>Constraints: Must be the name of an existing snapshot that is in the
+     * <code>available</code>, <code>failed</code>, or <code>cancelled</code>
+     * state.</p>
+     */
+    inline DeleteClusterSnapshotRequest& WithSnapshotIdentifier(const Aws::String& value) { SetSnapshotIdentifier(value); return *this;}
+
+    /**
+     * <p>The unique identifier of the manual snapshot to be deleted.</p>
+     * <p>Constraints: Must be the name of an existing snapshot that is in the
+     * <code>available</code>, <code>failed</code>, or <code>cancelled</code>
+     * state.</p>
+     */
+    inline DeleteClusterSnapshotRequest& WithSnapshotIdentifier(Aws::String&& value) { SetSnapshotIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>The unique identifier of the manual snapshot to be deleted.</p>
+     * <p>Constraints: Must be the name of an existing snapshot that is in the
+     * <code>available</code>, <code>failed</code>, or <code>cancelled</code>
+     * state.</p>
+     */
+    inline DeleteClusterSnapshotRequest& WithSnapshotIdentifier(const char* value) { SetSnapshotIdentifier(value); return *this;}
+
+
+    /**
+     * <p>The unique identifier of the cluster the snapshot was created from. This
+     * parameter is required if your IAM user has a policy containing a snapshot
+     * resource element that specifies anything other than * for the cluster name.</p>
+     * <p>Constraints: Must be the name of valid cluster.</p>
+     */
+    inline const Aws::String& GetSnapshotClusterIdentifier() const{ return m_snapshotClusterIdentifier; }
+
+    /**
+     * <p>The unique identifier of the cluster the snapshot was created from. This
+     * parameter is required if your IAM user has a policy containing a snapshot
+     * resource element that specifies anything other than * for the cluster name.</p>
+     * <p>Constraints: Must be the name of valid cluster.</p>
+     */
+    inline bool SnapshotClusterIdentifierHasBeenSet() const { return m_snapshotClusterIdentifierHasBeenSet; }
+
+    /**
+     * <p>The unique identifier of the cluster the snapshot was created from. This
+     * parameter is required if your IAM user has a policy containing a snapshot
+     * resource element that specifies anything other than * for the cluster name.</p>
+     * <p>Constraints: Must be the name of valid cluster.</p>
+     */
+    inline void SetSnapshotClusterIdentifier(const Aws::String& value) { m_snapshotClusterIdentifierHasBeenSet = true; m_snapshotClusterIdentifier = value; }
+
+    /**
+     * <p>The unique identifier of the cluster the snapshot was created from. This
+     * parameter is required if your IAM user has a policy containing a snapshot
+     * resource element that specifies anything other than * for the cluster name.</p>
+     * <p>Constraints: Must be the name of valid cluster.</p>
+     */
+    inline void SetSnapshotClusterIdentifier(Aws::String&& value) { m_snapshotClusterIdentifierHasBeenSet = true; m_snapshotClusterIdentifier = std::move(value); }
+
+    /**
+     * <p>The unique identifier of the cluster the snapshot was created from. This
+     * parameter is required if your IAM user has a policy containing a snapshot
+     * resource element that specifies anything other than * for the cluster name.</p>
+     * <p>Constraints: Must be the name of valid cluster.</p>
+     */
+    inline void SetSnapshotClusterIdentifier(const char* value) { m_snapshotClusterIdentifierHasBeenSet = true; m_snapshotClusterIdentifier.assign(value); }
+
+    /**
+     * <p>The unique identifier of the cluster the snapshot was created from. This
+     * parameter is required if your IAM user has a policy containing a snapshot
+     * resource element that specifies anything other than * for the cluster name.</p>
+     * <p>Constraints: Must be the name of valid cluster.</p>
+     */
+    inline DeleteClusterSnapshotRequest& WithSnapshotClusterIdentifier(const Aws::String& value) { SetSnapshotClusterIdentifier(value); return *this;}
+
+    /**
+     * <p>The unique identifier of the cluster the snapshot was created from. This
+     * parameter is required if your IAM user has a policy containing a snapshot
+     * resource element that specifies anything other than * for the cluster name.</p>
+     * <p>Constraints: Must be the name of valid cluster.</p>
+     */
+    inline DeleteClusterSnapshotRequest& WithSnapshotClusterIdentifier(Aws::String&& value) { SetSnapshotClusterIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>The unique identifier of the cluster the snapshot was created from. This
+     * parameter is required if your IAM user has a policy containing a snapshot
+     * resource element that specifies anything other than * for the cluster name.</p>
+     * <p>Constraints: Must be the name of valid cluster.</p>
+     */
+    inline DeleteClusterSnapshotRequest& WithSnapshotClusterIdentifier(const char* value) { SetSnapshotClusterIdentifier(value); return *this;}
+
+  private:
+
+    Aws::String m_snapshotIdentifier;
+    bool m_snapshotIdentifierHasBeenSet;
+
+    Aws::String m_snapshotClusterIdentifier;
+    bool m_snapshotClusterIdentifierHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DeleteClusterSnapshotResult.h

@@ -0,0 +1,76 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/model/Snapshot.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  class AWS_REDSHIFT_API DeleteClusterSnapshotResult
+  {
+  public:
+    DeleteClusterSnapshotResult();
+    DeleteClusterSnapshotResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    DeleteClusterSnapshotResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    
+    inline const Snapshot& GetSnapshot() const{ return m_snapshot; }
+
+    
+    inline void SetSnapshot(const Snapshot& value) { m_snapshot = value; }
+
+    
+    inline void SetSnapshot(Snapshot&& value) { m_snapshot = std::move(value); }
+
+    
+    inline DeleteClusterSnapshotResult& WithSnapshot(const Snapshot& value) { SetSnapshot(value); return *this;}
+
+    
+    inline DeleteClusterSnapshotResult& WithSnapshot(Snapshot&& value) { SetSnapshot(std::move(value)); return *this;}
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline DeleteClusterSnapshotResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline DeleteClusterSnapshotResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    Snapshot m_snapshot;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DeleteClusterSubnetGroupRequest.h

@@ -0,0 +1,90 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p/><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/DeleteClusterSubnetGroupMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API DeleteClusterSubnetGroupRequest : public RedshiftRequest
+  {
+  public:
+    DeleteClusterSubnetGroupRequest();
+
+    // 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 "DeleteClusterSubnetGroup"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The name of the cluster subnet group name to be deleted.</p>
+     */
+    inline const Aws::String& GetClusterSubnetGroupName() const{ return m_clusterSubnetGroupName; }
+
+    /**
+     * <p>The name of the cluster subnet group name to be deleted.</p>
+     */
+    inline bool ClusterSubnetGroupNameHasBeenSet() const { return m_clusterSubnetGroupNameHasBeenSet; }
+
+    /**
+     * <p>The name of the cluster subnet group name to be deleted.</p>
+     */
+    inline void SetClusterSubnetGroupName(const Aws::String& value) { m_clusterSubnetGroupNameHasBeenSet = true; m_clusterSubnetGroupName = value; }
+
+    /**
+     * <p>The name of the cluster subnet group name to be deleted.</p>
+     */
+    inline void SetClusterSubnetGroupName(Aws::String&& value) { m_clusterSubnetGroupNameHasBeenSet = true; m_clusterSubnetGroupName = std::move(value); }
+
+    /**
+     * <p>The name of the cluster subnet group name to be deleted.</p>
+     */
+    inline void SetClusterSubnetGroupName(const char* value) { m_clusterSubnetGroupNameHasBeenSet = true; m_clusterSubnetGroupName.assign(value); }
+
+    /**
+     * <p>The name of the cluster subnet group name to be deleted.</p>
+     */
+    inline DeleteClusterSubnetGroupRequest& WithClusterSubnetGroupName(const Aws::String& value) { SetClusterSubnetGroupName(value); return *this;}
+
+    /**
+     * <p>The name of the cluster subnet group name to be deleted.</p>
+     */
+    inline DeleteClusterSubnetGroupRequest& WithClusterSubnetGroupName(Aws::String&& value) { SetClusterSubnetGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the cluster subnet group name to be deleted.</p>
+     */
+    inline DeleteClusterSubnetGroupRequest& WithClusterSubnetGroupName(const char* value) { SetClusterSubnetGroupName(value); return *this;}
+
+  private:
+
+    Aws::String m_clusterSubnetGroupName;
+    bool m_clusterSubnetGroupNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DeleteEventSubscriptionRequest.h

@@ -0,0 +1,98 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p/><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/DeleteEventSubscriptionMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API DeleteEventSubscriptionRequest : public RedshiftRequest
+  {
+  public:
+    DeleteEventSubscriptionRequest();
+
+    // 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 "DeleteEventSubscription"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The name of the Amazon Redshift event notification subscription to be
+     * deleted.</p>
+     */
+    inline const Aws::String& GetSubscriptionName() const{ return m_subscriptionName; }
+
+    /**
+     * <p>The name of the Amazon Redshift event notification subscription to be
+     * deleted.</p>
+     */
+    inline bool SubscriptionNameHasBeenSet() const { return m_subscriptionNameHasBeenSet; }
+
+    /**
+     * <p>The name of the Amazon Redshift event notification subscription to be
+     * deleted.</p>
+     */
+    inline void SetSubscriptionName(const Aws::String& value) { m_subscriptionNameHasBeenSet = true; m_subscriptionName = value; }
+
+    /**
+     * <p>The name of the Amazon Redshift event notification subscription to be
+     * deleted.</p>
+     */
+    inline void SetSubscriptionName(Aws::String&& value) { m_subscriptionNameHasBeenSet = true; m_subscriptionName = std::move(value); }
+
+    /**
+     * <p>The name of the Amazon Redshift event notification subscription to be
+     * deleted.</p>
+     */
+    inline void SetSubscriptionName(const char* value) { m_subscriptionNameHasBeenSet = true; m_subscriptionName.assign(value); }
+
+    /**
+     * <p>The name of the Amazon Redshift event notification subscription to be
+     * deleted.</p>
+     */
+    inline DeleteEventSubscriptionRequest& WithSubscriptionName(const Aws::String& value) { SetSubscriptionName(value); return *this;}
+
+    /**
+     * <p>The name of the Amazon Redshift event notification subscription to be
+     * deleted.</p>
+     */
+    inline DeleteEventSubscriptionRequest& WithSubscriptionName(Aws::String&& value) { SetSubscriptionName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the Amazon Redshift event notification subscription to be
+     * deleted.</p>
+     */
+    inline DeleteEventSubscriptionRequest& WithSubscriptionName(const char* value) { SetSubscriptionName(value); return *this;}
+
+  private:
+
+    Aws::String m_subscriptionName;
+    bool m_subscriptionNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DeleteHsmClientCertificateRequest.h

@@ -0,0 +1,90 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p/><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/DeleteHsmClientCertificateMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API DeleteHsmClientCertificateRequest : public RedshiftRequest
+  {
+  public:
+    DeleteHsmClientCertificateRequest();
+
+    // 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 "DeleteHsmClientCertificate"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The identifier of the HSM client certificate to be deleted.</p>
+     */
+    inline const Aws::String& GetHsmClientCertificateIdentifier() const{ return m_hsmClientCertificateIdentifier; }
+
+    /**
+     * <p>The identifier of the HSM client certificate to be deleted.</p>
+     */
+    inline bool HsmClientCertificateIdentifierHasBeenSet() const { return m_hsmClientCertificateIdentifierHasBeenSet; }
+
+    /**
+     * <p>The identifier of the HSM client certificate to be deleted.</p>
+     */
+    inline void SetHsmClientCertificateIdentifier(const Aws::String& value) { m_hsmClientCertificateIdentifierHasBeenSet = true; m_hsmClientCertificateIdentifier = value; }
+
+    /**
+     * <p>The identifier of the HSM client certificate to be deleted.</p>
+     */
+    inline void SetHsmClientCertificateIdentifier(Aws::String&& value) { m_hsmClientCertificateIdentifierHasBeenSet = true; m_hsmClientCertificateIdentifier = std::move(value); }
+
+    /**
+     * <p>The identifier of the HSM client certificate to be deleted.</p>
+     */
+    inline void SetHsmClientCertificateIdentifier(const char* value) { m_hsmClientCertificateIdentifierHasBeenSet = true; m_hsmClientCertificateIdentifier.assign(value); }
+
+    /**
+     * <p>The identifier of the HSM client certificate to be deleted.</p>
+     */
+    inline DeleteHsmClientCertificateRequest& WithHsmClientCertificateIdentifier(const Aws::String& value) { SetHsmClientCertificateIdentifier(value); return *this;}
+
+    /**
+     * <p>The identifier of the HSM client certificate to be deleted.</p>
+     */
+    inline DeleteHsmClientCertificateRequest& WithHsmClientCertificateIdentifier(Aws::String&& value) { SetHsmClientCertificateIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>The identifier of the HSM client certificate to be deleted.</p>
+     */
+    inline DeleteHsmClientCertificateRequest& WithHsmClientCertificateIdentifier(const char* value) { SetHsmClientCertificateIdentifier(value); return *this;}
+
+  private:
+
+    Aws::String m_hsmClientCertificateIdentifier;
+    bool m_hsmClientCertificateIdentifierHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DeleteHsmConfigurationRequest.h

@@ -0,0 +1,90 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p/><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/DeleteHsmConfigurationMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API DeleteHsmConfigurationRequest : public RedshiftRequest
+  {
+  public:
+    DeleteHsmConfigurationRequest();
+
+    // 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 "DeleteHsmConfiguration"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The identifier of the Amazon Redshift HSM configuration to be deleted.</p>
+     */
+    inline const Aws::String& GetHsmConfigurationIdentifier() const{ return m_hsmConfigurationIdentifier; }
+
+    /**
+     * <p>The identifier of the Amazon Redshift HSM configuration to be deleted.</p>
+     */
+    inline bool HsmConfigurationIdentifierHasBeenSet() const { return m_hsmConfigurationIdentifierHasBeenSet; }
+
+    /**
+     * <p>The identifier of the Amazon Redshift HSM configuration to be deleted.</p>
+     */
+    inline void SetHsmConfigurationIdentifier(const Aws::String& value) { m_hsmConfigurationIdentifierHasBeenSet = true; m_hsmConfigurationIdentifier = value; }
+
+    /**
+     * <p>The identifier of the Amazon Redshift HSM configuration to be deleted.</p>
+     */
+    inline void SetHsmConfigurationIdentifier(Aws::String&& value) { m_hsmConfigurationIdentifierHasBeenSet = true; m_hsmConfigurationIdentifier = std::move(value); }
+
+    /**
+     * <p>The identifier of the Amazon Redshift HSM configuration to be deleted.</p>
+     */
+    inline void SetHsmConfigurationIdentifier(const char* value) { m_hsmConfigurationIdentifierHasBeenSet = true; m_hsmConfigurationIdentifier.assign(value); }
+
+    /**
+     * <p>The identifier of the Amazon Redshift HSM configuration to be deleted.</p>
+     */
+    inline DeleteHsmConfigurationRequest& WithHsmConfigurationIdentifier(const Aws::String& value) { SetHsmConfigurationIdentifier(value); return *this;}
+
+    /**
+     * <p>The identifier of the Amazon Redshift HSM configuration to be deleted.</p>
+     */
+    inline DeleteHsmConfigurationRequest& WithHsmConfigurationIdentifier(Aws::String&& value) { SetHsmConfigurationIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>The identifier of the Amazon Redshift HSM configuration to be deleted.</p>
+     */
+    inline DeleteHsmConfigurationRequest& WithHsmConfigurationIdentifier(const char* value) { SetHsmConfigurationIdentifier(value); return *this;}
+
+  private:
+
+    Aws::String m_hsmConfigurationIdentifier;
+    bool m_hsmConfigurationIdentifierHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DeleteScheduledActionRequest.h

@@ -0,0 +1,87 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_REDSHIFT_API DeleteScheduledActionRequest : public RedshiftRequest
+  {
+  public:
+    DeleteScheduledActionRequest();
+
+    // 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 "DeleteScheduledAction"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The name of the scheduled action to delete. </p>
+     */
+    inline const Aws::String& GetScheduledActionName() const{ return m_scheduledActionName; }
+
+    /**
+     * <p>The name of the scheduled action to delete. </p>
+     */
+    inline bool ScheduledActionNameHasBeenSet() const { return m_scheduledActionNameHasBeenSet; }
+
+    /**
+     * <p>The name of the scheduled action to delete. </p>
+     */
+    inline void SetScheduledActionName(const Aws::String& value) { m_scheduledActionNameHasBeenSet = true; m_scheduledActionName = value; }
+
+    /**
+     * <p>The name of the scheduled action to delete. </p>
+     */
+    inline void SetScheduledActionName(Aws::String&& value) { m_scheduledActionNameHasBeenSet = true; m_scheduledActionName = std::move(value); }
+
+    /**
+     * <p>The name of the scheduled action to delete. </p>
+     */
+    inline void SetScheduledActionName(const char* value) { m_scheduledActionNameHasBeenSet = true; m_scheduledActionName.assign(value); }
+
+    /**
+     * <p>The name of the scheduled action to delete. </p>
+     */
+    inline DeleteScheduledActionRequest& WithScheduledActionName(const Aws::String& value) { SetScheduledActionName(value); return *this;}
+
+    /**
+     * <p>The name of the scheduled action to delete. </p>
+     */
+    inline DeleteScheduledActionRequest& WithScheduledActionName(Aws::String&& value) { SetScheduledActionName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the scheduled action to delete. </p>
+     */
+    inline DeleteScheduledActionRequest& WithScheduledActionName(const char* value) { SetScheduledActionName(value); return *this;}
+
+  private:
+
+    Aws::String m_scheduledActionName;
+    bool m_scheduledActionNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DeleteSnapshotCopyGrantRequest.h

@@ -0,0 +1,91 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p>The result of the <code>DeleteSnapshotCopyGrant</code> action.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/DeleteSnapshotCopyGrantMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API DeleteSnapshotCopyGrantRequest : public RedshiftRequest
+  {
+  public:
+    DeleteSnapshotCopyGrantRequest();
+
+    // 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 "DeleteSnapshotCopyGrant"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The name of the snapshot copy grant to delete.</p>
+     */
+    inline const Aws::String& GetSnapshotCopyGrantName() const{ return m_snapshotCopyGrantName; }
+
+    /**
+     * <p>The name of the snapshot copy grant to delete.</p>
+     */
+    inline bool SnapshotCopyGrantNameHasBeenSet() const { return m_snapshotCopyGrantNameHasBeenSet; }
+
+    /**
+     * <p>The name of the snapshot copy grant to delete.</p>
+     */
+    inline void SetSnapshotCopyGrantName(const Aws::String& value) { m_snapshotCopyGrantNameHasBeenSet = true; m_snapshotCopyGrantName = value; }
+
+    /**
+     * <p>The name of the snapshot copy grant to delete.</p>
+     */
+    inline void SetSnapshotCopyGrantName(Aws::String&& value) { m_snapshotCopyGrantNameHasBeenSet = true; m_snapshotCopyGrantName = std::move(value); }
+
+    /**
+     * <p>The name of the snapshot copy grant to delete.</p>
+     */
+    inline void SetSnapshotCopyGrantName(const char* value) { m_snapshotCopyGrantNameHasBeenSet = true; m_snapshotCopyGrantName.assign(value); }
+
+    /**
+     * <p>The name of the snapshot copy grant to delete.</p>
+     */
+    inline DeleteSnapshotCopyGrantRequest& WithSnapshotCopyGrantName(const Aws::String& value) { SetSnapshotCopyGrantName(value); return *this;}
+
+    /**
+     * <p>The name of the snapshot copy grant to delete.</p>
+     */
+    inline DeleteSnapshotCopyGrantRequest& WithSnapshotCopyGrantName(Aws::String&& value) { SetSnapshotCopyGrantName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the snapshot copy grant to delete.</p>
+     */
+    inline DeleteSnapshotCopyGrantRequest& WithSnapshotCopyGrantName(const char* value) { SetSnapshotCopyGrantName(value); return *this;}
+
+  private:
+
+    Aws::String m_snapshotCopyGrantName;
+    bool m_snapshotCopyGrantNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DeleteSnapshotScheduleRequest.h

@@ -0,0 +1,87 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_REDSHIFT_API DeleteSnapshotScheduleRequest : public RedshiftRequest
+  {
+  public:
+    DeleteSnapshotScheduleRequest();
+
+    // 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 "DeleteSnapshotSchedule"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>A unique identifier of the snapshot schedule to delete.</p>
+     */
+    inline const Aws::String& GetScheduleIdentifier() const{ return m_scheduleIdentifier; }
+
+    /**
+     * <p>A unique identifier of the snapshot schedule to delete.</p>
+     */
+    inline bool ScheduleIdentifierHasBeenSet() const { return m_scheduleIdentifierHasBeenSet; }
+
+    /**
+     * <p>A unique identifier of the snapshot schedule to delete.</p>
+     */
+    inline void SetScheduleIdentifier(const Aws::String& value) { m_scheduleIdentifierHasBeenSet = true; m_scheduleIdentifier = value; }
+
+    /**
+     * <p>A unique identifier of the snapshot schedule to delete.</p>
+     */
+    inline void SetScheduleIdentifier(Aws::String&& value) { m_scheduleIdentifierHasBeenSet = true; m_scheduleIdentifier = std::move(value); }
+
+    /**
+     * <p>A unique identifier of the snapshot schedule to delete.</p>
+     */
+    inline void SetScheduleIdentifier(const char* value) { m_scheduleIdentifierHasBeenSet = true; m_scheduleIdentifier.assign(value); }
+
+    /**
+     * <p>A unique identifier of the snapshot schedule to delete.</p>
+     */
+    inline DeleteSnapshotScheduleRequest& WithScheduleIdentifier(const Aws::String& value) { SetScheduleIdentifier(value); return *this;}
+
+    /**
+     * <p>A unique identifier of the snapshot schedule to delete.</p>
+     */
+    inline DeleteSnapshotScheduleRequest& WithScheduleIdentifier(Aws::String&& value) { SetScheduleIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>A unique identifier of the snapshot schedule to delete.</p>
+     */
+    inline DeleteSnapshotScheduleRequest& WithScheduleIdentifier(const char* value) { SetScheduleIdentifier(value); return *this;}
+
+  private:
+
+    Aws::String m_scheduleIdentifier;
+    bool m_scheduleIdentifierHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DeleteTagsRequest.h

@@ -0,0 +1,149 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p>Contains the output from the <code>DeleteTags</code> action. </p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/DeleteTagsMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API DeleteTagsRequest : public RedshiftRequest
+  {
+  public:
+    DeleteTagsRequest();
+
+    // 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 "DeleteTags"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The Amazon Resource Name (ARN) from which you want to remove the tag or tags.
+     * For example, <code>arn:aws:redshift:us-east-2:123456789:cluster:t1</code>. </p>
+     */
+    inline const Aws::String& GetResourceName() const{ return m_resourceName; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) from which you want to remove the tag or tags.
+     * For example, <code>arn:aws:redshift:us-east-2:123456789:cluster:t1</code>. </p>
+     */
+    inline bool ResourceNameHasBeenSet() const { return m_resourceNameHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) from which you want to remove the tag or tags.
+     * For example, <code>arn:aws:redshift:us-east-2:123456789:cluster:t1</code>. </p>
+     */
+    inline void SetResourceName(const Aws::String& value) { m_resourceNameHasBeenSet = true; m_resourceName = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) from which you want to remove the tag or tags.
+     * For example, <code>arn:aws:redshift:us-east-2:123456789:cluster:t1</code>. </p>
+     */
+    inline void SetResourceName(Aws::String&& value) { m_resourceNameHasBeenSet = true; m_resourceName = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) from which you want to remove the tag or tags.
+     * For example, <code>arn:aws:redshift:us-east-2:123456789:cluster:t1</code>. </p>
+     */
+    inline void SetResourceName(const char* value) { m_resourceNameHasBeenSet = true; m_resourceName.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) from which you want to remove the tag or tags.
+     * For example, <code>arn:aws:redshift:us-east-2:123456789:cluster:t1</code>. </p>
+     */
+    inline DeleteTagsRequest& WithResourceName(const Aws::String& value) { SetResourceName(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) from which you want to remove the tag or tags.
+     * For example, <code>arn:aws:redshift:us-east-2:123456789:cluster:t1</code>. </p>
+     */
+    inline DeleteTagsRequest& WithResourceName(Aws::String&& value) { SetResourceName(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) from which you want to remove the tag or tags.
+     * For example, <code>arn:aws:redshift:us-east-2:123456789:cluster:t1</code>. </p>
+     */
+    inline DeleteTagsRequest& WithResourceName(const char* value) { SetResourceName(value); return *this;}
+
+
+    /**
+     * <p>The tag key that you want to delete.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetTagKeys() const{ return m_tagKeys; }
+
+    /**
+     * <p>The tag key that you want to delete.</p>
+     */
+    inline bool TagKeysHasBeenSet() const { return m_tagKeysHasBeenSet; }
+
+    /**
+     * <p>The tag key that you want to delete.</p>
+     */
+    inline void SetTagKeys(const Aws::Vector<Aws::String>& value) { m_tagKeysHasBeenSet = true; m_tagKeys = value; }
+
+    /**
+     * <p>The tag key that you want to delete.</p>
+     */
+    inline void SetTagKeys(Aws::Vector<Aws::String>&& value) { m_tagKeysHasBeenSet = true; m_tagKeys = std::move(value); }
+
+    /**
+     * <p>The tag key that you want to delete.</p>
+     */
+    inline DeleteTagsRequest& WithTagKeys(const Aws::Vector<Aws::String>& value) { SetTagKeys(value); return *this;}
+
+    /**
+     * <p>The tag key that you want to delete.</p>
+     */
+    inline DeleteTagsRequest& WithTagKeys(Aws::Vector<Aws::String>&& value) { SetTagKeys(std::move(value)); return *this;}
+
+    /**
+     * <p>The tag key that you want to delete.</p>
+     */
+    inline DeleteTagsRequest& AddTagKeys(const Aws::String& value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(value); return *this; }
+
+    /**
+     * <p>The tag key that you want to delete.</p>
+     */
+    inline DeleteTagsRequest& AddTagKeys(Aws::String&& value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>The tag key that you want to delete.</p>
+     */
+    inline DeleteTagsRequest& 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 Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DeleteUsageLimitRequest.h

@@ -0,0 +1,87 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_REDSHIFT_API DeleteUsageLimitRequest : public RedshiftRequest
+  {
+  public:
+    DeleteUsageLimitRequest();
+
+    // 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 "DeleteUsageLimit"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The identifier of the usage limit to delete.</p>
+     */
+    inline const Aws::String& GetUsageLimitId() const{ return m_usageLimitId; }
+
+    /**
+     * <p>The identifier of the usage limit to delete.</p>
+     */
+    inline bool UsageLimitIdHasBeenSet() const { return m_usageLimitIdHasBeenSet; }
+
+    /**
+     * <p>The identifier of the usage limit to delete.</p>
+     */
+    inline void SetUsageLimitId(const Aws::String& value) { m_usageLimitIdHasBeenSet = true; m_usageLimitId = value; }
+
+    /**
+     * <p>The identifier of the usage limit to delete.</p>
+     */
+    inline void SetUsageLimitId(Aws::String&& value) { m_usageLimitIdHasBeenSet = true; m_usageLimitId = std::move(value); }
+
+    /**
+     * <p>The identifier of the usage limit to delete.</p>
+     */
+    inline void SetUsageLimitId(const char* value) { m_usageLimitIdHasBeenSet = true; m_usageLimitId.assign(value); }
+
+    /**
+     * <p>The identifier of the usage limit to delete.</p>
+     */
+    inline DeleteUsageLimitRequest& WithUsageLimitId(const Aws::String& value) { SetUsageLimitId(value); return *this;}
+
+    /**
+     * <p>The identifier of the usage limit to delete.</p>
+     */
+    inline DeleteUsageLimitRequest& WithUsageLimitId(Aws::String&& value) { SetUsageLimitId(std::move(value)); return *this;}
+
+    /**
+     * <p>The identifier of the usage limit to delete.</p>
+     */
+    inline DeleteUsageLimitRequest& WithUsageLimitId(const char* value) { SetUsageLimitId(value); return *this;}
+
+  private:
+
+    Aws::String m_usageLimitId;
+    bool m_usageLimitIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DescribeAccountAttributesRequest.h

@@ -0,0 +1,93 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_REDSHIFT_API DescribeAccountAttributesRequest : public RedshiftRequest
+  {
+  public:
+    DescribeAccountAttributesRequest();
+
+    // 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 "DescribeAccountAttributes"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>A list of attribute names.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetAttributeNames() const{ return m_attributeNames; }
+
+    /**
+     * <p>A list of attribute names.</p>
+     */
+    inline bool AttributeNamesHasBeenSet() const { return m_attributeNamesHasBeenSet; }
+
+    /**
+     * <p>A list of attribute names.</p>
+     */
+    inline void SetAttributeNames(const Aws::Vector<Aws::String>& value) { m_attributeNamesHasBeenSet = true; m_attributeNames = value; }
+
+    /**
+     * <p>A list of attribute names.</p>
+     */
+    inline void SetAttributeNames(Aws::Vector<Aws::String>&& value) { m_attributeNamesHasBeenSet = true; m_attributeNames = std::move(value); }
+
+    /**
+     * <p>A list of attribute names.</p>
+     */
+    inline DescribeAccountAttributesRequest& WithAttributeNames(const Aws::Vector<Aws::String>& value) { SetAttributeNames(value); return *this;}
+
+    /**
+     * <p>A list of attribute names.</p>
+     */
+    inline DescribeAccountAttributesRequest& WithAttributeNames(Aws::Vector<Aws::String>&& value) { SetAttributeNames(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of attribute names.</p>
+     */
+    inline DescribeAccountAttributesRequest& AddAttributeNames(const Aws::String& value) { m_attributeNamesHasBeenSet = true; m_attributeNames.push_back(value); return *this; }
+
+    /**
+     * <p>A list of attribute names.</p>
+     */
+    inline DescribeAccountAttributesRequest& AddAttributeNames(Aws::String&& value) { m_attributeNamesHasBeenSet = true; m_attributeNames.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>A list of attribute names.</p>
+     */
+    inline DescribeAccountAttributesRequest& AddAttributeNames(const char* value) { m_attributeNamesHasBeenSet = true; m_attributeNames.push_back(value); return *this; }
+
+  private:
+
+    Aws::Vector<Aws::String> m_attributeNames;
+    bool m_attributeNamesHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DescribeAccountAttributesResult.h

@@ -0,0 +1,97 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <aws/redshift/model/AccountAttribute.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  class AWS_REDSHIFT_API DescribeAccountAttributesResult
+  {
+  public:
+    DescribeAccountAttributesResult();
+    DescribeAccountAttributesResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    DescribeAccountAttributesResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    /**
+     * <p>A list of attributes assigned to an account.</p>
+     */
+    inline const Aws::Vector<AccountAttribute>& GetAccountAttributes() const{ return m_accountAttributes; }
+
+    /**
+     * <p>A list of attributes assigned to an account.</p>
+     */
+    inline void SetAccountAttributes(const Aws::Vector<AccountAttribute>& value) { m_accountAttributes = value; }
+
+    /**
+     * <p>A list of attributes assigned to an account.</p>
+     */
+    inline void SetAccountAttributes(Aws::Vector<AccountAttribute>&& value) { m_accountAttributes = std::move(value); }
+
+    /**
+     * <p>A list of attributes assigned to an account.</p>
+     */
+    inline DescribeAccountAttributesResult& WithAccountAttributes(const Aws::Vector<AccountAttribute>& value) { SetAccountAttributes(value); return *this;}
+
+    /**
+     * <p>A list of attributes assigned to an account.</p>
+     */
+    inline DescribeAccountAttributesResult& WithAccountAttributes(Aws::Vector<AccountAttribute>&& value) { SetAccountAttributes(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of attributes assigned to an account.</p>
+     */
+    inline DescribeAccountAttributesResult& AddAccountAttributes(const AccountAttribute& value) { m_accountAttributes.push_back(value); return *this; }
+
+    /**
+     * <p>A list of attributes assigned to an account.</p>
+     */
+    inline DescribeAccountAttributesResult& AddAccountAttributes(AccountAttribute&& value) { m_accountAttributes.push_back(std::move(value)); return *this; }
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline DescribeAccountAttributesResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline DescribeAccountAttributesResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    Aws::Vector<AccountAttribute> m_accountAttributes;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DescribeClusterDbRevisionsRequest.h

@@ -0,0 +1,255 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_REDSHIFT_API DescribeClusterDbRevisionsRequest : public RedshiftRequest
+  {
+  public:
+    DescribeClusterDbRevisionsRequest();
+
+    // 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 "DescribeClusterDbRevisions"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>A unique identifier for a cluster whose <code>ClusterDbRevisions</code> you
+     * are requesting. This parameter is case sensitive. All clusters defined for an
+     * account are returned by default.</p>
+     */
+    inline const Aws::String& GetClusterIdentifier() const{ return m_clusterIdentifier; }
+
+    /**
+     * <p>A unique identifier for a cluster whose <code>ClusterDbRevisions</code> you
+     * are requesting. This parameter is case sensitive. All clusters defined for an
+     * account are returned by default.</p>
+     */
+    inline bool ClusterIdentifierHasBeenSet() const { return m_clusterIdentifierHasBeenSet; }
+
+    /**
+     * <p>A unique identifier for a cluster whose <code>ClusterDbRevisions</code> you
+     * are requesting. This parameter is case sensitive. All clusters defined for an
+     * account are returned by default.</p>
+     */
+    inline void SetClusterIdentifier(const Aws::String& value) { m_clusterIdentifierHasBeenSet = true; m_clusterIdentifier = value; }
+
+    /**
+     * <p>A unique identifier for a cluster whose <code>ClusterDbRevisions</code> you
+     * are requesting. This parameter is case sensitive. All clusters defined for an
+     * account are returned by default.</p>
+     */
+    inline void SetClusterIdentifier(Aws::String&& value) { m_clusterIdentifierHasBeenSet = true; m_clusterIdentifier = std::move(value); }
+
+    /**
+     * <p>A unique identifier for a cluster whose <code>ClusterDbRevisions</code> you
+     * are requesting. This parameter is case sensitive. All clusters defined for an
+     * account are returned by default.</p>
+     */
+    inline void SetClusterIdentifier(const char* value) { m_clusterIdentifierHasBeenSet = true; m_clusterIdentifier.assign(value); }
+
+    /**
+     * <p>A unique identifier for a cluster whose <code>ClusterDbRevisions</code> you
+     * are requesting. This parameter is case sensitive. All clusters defined for an
+     * account are returned by default.</p>
+     */
+    inline DescribeClusterDbRevisionsRequest& WithClusterIdentifier(const Aws::String& value) { SetClusterIdentifier(value); return *this;}
+
+    /**
+     * <p>A unique identifier for a cluster whose <code>ClusterDbRevisions</code> you
+     * are requesting. This parameter is case sensitive. All clusters defined for an
+     * account are returned by default.</p>
+     */
+    inline DescribeClusterDbRevisionsRequest& WithClusterIdentifier(Aws::String&& value) { SetClusterIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>A unique identifier for a cluster whose <code>ClusterDbRevisions</code> you
+     * are requesting. This parameter is case sensitive. All clusters defined for an
+     * account are returned by default.</p>
+     */
+    inline DescribeClusterDbRevisionsRequest& WithClusterIdentifier(const char* value) { SetClusterIdentifier(value); return *this;}
+
+
+    /**
+     * <p>The maximum number of response records to return in each call. If the number
+     * of remaining response records exceeds the specified MaxRecords value, a value is
+     * returned in the <code>marker</code> field of the response. You can retrieve the
+     * next set of response records by providing the returned <code>marker</code> value
+     * in the <code>marker</code> parameter and retrying the request. </p> <p>Default:
+     * 100</p> <p>Constraints: minimum 20, maximum 100.</p>
+     */
+    inline int GetMaxRecords() const{ return m_maxRecords; }
+
+    /**
+     * <p>The maximum number of response records to return in each call. If the number
+     * of remaining response records exceeds the specified MaxRecords value, a value is
+     * returned in the <code>marker</code> field of the response. You can retrieve the
+     * next set of response records by providing the returned <code>marker</code> value
+     * in the <code>marker</code> parameter and retrying the request. </p> <p>Default:
+     * 100</p> <p>Constraints: minimum 20, maximum 100.</p>
+     */
+    inline bool MaxRecordsHasBeenSet() const { return m_maxRecordsHasBeenSet; }
+
+    /**
+     * <p>The maximum number of response records to return in each call. If the number
+     * of remaining response records exceeds the specified MaxRecords value, a value is
+     * returned in the <code>marker</code> field of the response. You can retrieve the
+     * next set of response records by providing the returned <code>marker</code> value
+     * in the <code>marker</code> parameter and retrying the request. </p> <p>Default:
+     * 100</p> <p>Constraints: minimum 20, maximum 100.</p>
+     */
+    inline void SetMaxRecords(int value) { m_maxRecordsHasBeenSet = true; m_maxRecords = value; }
+
+    /**
+     * <p>The maximum number of response records to return in each call. If the number
+     * of remaining response records exceeds the specified MaxRecords value, a value is
+     * returned in the <code>marker</code> field of the response. You can retrieve the
+     * next set of response records by providing the returned <code>marker</code> value
+     * in the <code>marker</code> parameter and retrying the request. </p> <p>Default:
+     * 100</p> <p>Constraints: minimum 20, maximum 100.</p>
+     */
+    inline DescribeClusterDbRevisionsRequest& WithMaxRecords(int value) { SetMaxRecords(value); return *this;}
+
+
+    /**
+     * <p>An optional parameter that specifies the starting point for returning a set
+     * of response records. When the results of a
+     * <code>DescribeClusterDbRevisions</code> request exceed the value specified in
+     * <code>MaxRecords</code>, Amazon Redshift returns a value in the
+     * <code>marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned <code>marker</code> value in the
+     * <code>marker</code> parameter and retrying the request. </p> <p>Constraints: You
+     * can specify either the <code>ClusterIdentifier</code> parameter, or the
+     * <code>marker</code> parameter, but not both.</p>
+     */
+    inline const Aws::String& GetMarker() const{ return m_marker; }
+
+    /**
+     * <p>An optional parameter that specifies the starting point for returning a set
+     * of response records. When the results of a
+     * <code>DescribeClusterDbRevisions</code> request exceed the value specified in
+     * <code>MaxRecords</code>, Amazon Redshift returns a value in the
+     * <code>marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned <code>marker</code> value in the
+     * <code>marker</code> parameter and retrying the request. </p> <p>Constraints: You
+     * can specify either the <code>ClusterIdentifier</code> parameter, or the
+     * <code>marker</code> parameter, but not both.</p>
+     */
+    inline bool MarkerHasBeenSet() const { return m_markerHasBeenSet; }
+
+    /**
+     * <p>An optional parameter that specifies the starting point for returning a set
+     * of response records. When the results of a
+     * <code>DescribeClusterDbRevisions</code> request exceed the value specified in
+     * <code>MaxRecords</code>, Amazon Redshift returns a value in the
+     * <code>marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned <code>marker</code> value in the
+     * <code>marker</code> parameter and retrying the request. </p> <p>Constraints: You
+     * can specify either the <code>ClusterIdentifier</code> parameter, or the
+     * <code>marker</code> parameter, but not both.</p>
+     */
+    inline void SetMarker(const Aws::String& value) { m_markerHasBeenSet = true; m_marker = value; }
+
+    /**
+     * <p>An optional parameter that specifies the starting point for returning a set
+     * of response records. When the results of a
+     * <code>DescribeClusterDbRevisions</code> request exceed the value specified in
+     * <code>MaxRecords</code>, Amazon Redshift returns a value in the
+     * <code>marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned <code>marker</code> value in the
+     * <code>marker</code> parameter and retrying the request. </p> <p>Constraints: You
+     * can specify either the <code>ClusterIdentifier</code> parameter, or the
+     * <code>marker</code> parameter, but not both.</p>
+     */
+    inline void SetMarker(Aws::String&& value) { m_markerHasBeenSet = true; m_marker = std::move(value); }
+
+    /**
+     * <p>An optional parameter that specifies the starting point for returning a set
+     * of response records. When the results of a
+     * <code>DescribeClusterDbRevisions</code> request exceed the value specified in
+     * <code>MaxRecords</code>, Amazon Redshift returns a value in the
+     * <code>marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned <code>marker</code> value in the
+     * <code>marker</code> parameter and retrying the request. </p> <p>Constraints: You
+     * can specify either the <code>ClusterIdentifier</code> parameter, or the
+     * <code>marker</code> parameter, but not both.</p>
+     */
+    inline void SetMarker(const char* value) { m_markerHasBeenSet = true; m_marker.assign(value); }
+
+    /**
+     * <p>An optional parameter that specifies the starting point for returning a set
+     * of response records. When the results of a
+     * <code>DescribeClusterDbRevisions</code> request exceed the value specified in
+     * <code>MaxRecords</code>, Amazon Redshift returns a value in the
+     * <code>marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned <code>marker</code> value in the
+     * <code>marker</code> parameter and retrying the request. </p> <p>Constraints: You
+     * can specify either the <code>ClusterIdentifier</code> parameter, or the
+     * <code>marker</code> parameter, but not both.</p>
+     */
+    inline DescribeClusterDbRevisionsRequest& WithMarker(const Aws::String& value) { SetMarker(value); return *this;}
+
+    /**
+     * <p>An optional parameter that specifies the starting point for returning a set
+     * of response records. When the results of a
+     * <code>DescribeClusterDbRevisions</code> request exceed the value specified in
+     * <code>MaxRecords</code>, Amazon Redshift returns a value in the
+     * <code>marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned <code>marker</code> value in the
+     * <code>marker</code> parameter and retrying the request. </p> <p>Constraints: You
+     * can specify either the <code>ClusterIdentifier</code> parameter, or the
+     * <code>marker</code> parameter, but not both.</p>
+     */
+    inline DescribeClusterDbRevisionsRequest& WithMarker(Aws::String&& value) { SetMarker(std::move(value)); return *this;}
+
+    /**
+     * <p>An optional parameter that specifies the starting point for returning a set
+     * of response records. When the results of a
+     * <code>DescribeClusterDbRevisions</code> request exceed the value specified in
+     * <code>MaxRecords</code>, Amazon Redshift returns a value in the
+     * <code>marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned <code>marker</code> value in the
+     * <code>marker</code> parameter and retrying the request. </p> <p>Constraints: You
+     * can specify either the <code>ClusterIdentifier</code> parameter, or the
+     * <code>marker</code> parameter, but not both.</p>
+     */
+    inline DescribeClusterDbRevisionsRequest& WithMarker(const char* value) { SetMarker(value); return *this;}
+
+  private:
+
+    Aws::String m_clusterIdentifier;
+    bool m_clusterIdentifierHasBeenSet;
+
+    int m_maxRecords;
+    bool m_maxRecordsHasBeenSet;
+
+    Aws::String m_marker;
+    bool m_markerHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DescribeClusterDbRevisionsResult.h

@@ -0,0 +1,164 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <aws/redshift/model/ClusterDbRevision.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  class AWS_REDSHIFT_API DescribeClusterDbRevisionsResult
+  {
+  public:
+    DescribeClusterDbRevisionsResult();
+    DescribeClusterDbRevisionsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    DescribeClusterDbRevisionsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    /**
+     * <p>A string representing the starting point for the next set of revisions. If a
+     * value is returned in a response, you can retrieve the next set of revisions by
+     * providing the value in the <code>marker</code> parameter and retrying the
+     * command. If the <code>marker</code> field is empty, all revisions have already
+     * been returned.</p>
+     */
+    inline const Aws::String& GetMarker() const{ return m_marker; }
+
+    /**
+     * <p>A string representing the starting point for the next set of revisions. If a
+     * value is returned in a response, you can retrieve the next set of revisions by
+     * providing the value in the <code>marker</code> parameter and retrying the
+     * command. If the <code>marker</code> field is empty, all revisions have already
+     * been returned.</p>
+     */
+    inline void SetMarker(const Aws::String& value) { m_marker = value; }
+
+    /**
+     * <p>A string representing the starting point for the next set of revisions. If a
+     * value is returned in a response, you can retrieve the next set of revisions by
+     * providing the value in the <code>marker</code> parameter and retrying the
+     * command. If the <code>marker</code> field is empty, all revisions have already
+     * been returned.</p>
+     */
+    inline void SetMarker(Aws::String&& value) { m_marker = std::move(value); }
+
+    /**
+     * <p>A string representing the starting point for the next set of revisions. If a
+     * value is returned in a response, you can retrieve the next set of revisions by
+     * providing the value in the <code>marker</code> parameter and retrying the
+     * command. If the <code>marker</code> field is empty, all revisions have already
+     * been returned.</p>
+     */
+    inline void SetMarker(const char* value) { m_marker.assign(value); }
+
+    /**
+     * <p>A string representing the starting point for the next set of revisions. If a
+     * value is returned in a response, you can retrieve the next set of revisions by
+     * providing the value in the <code>marker</code> parameter and retrying the
+     * command. If the <code>marker</code> field is empty, all revisions have already
+     * been returned.</p>
+     */
+    inline DescribeClusterDbRevisionsResult& WithMarker(const Aws::String& value) { SetMarker(value); return *this;}
+
+    /**
+     * <p>A string representing the starting point for the next set of revisions. If a
+     * value is returned in a response, you can retrieve the next set of revisions by
+     * providing the value in the <code>marker</code> parameter and retrying the
+     * command. If the <code>marker</code> field is empty, all revisions have already
+     * been returned.</p>
+     */
+    inline DescribeClusterDbRevisionsResult& WithMarker(Aws::String&& value) { SetMarker(std::move(value)); return *this;}
+
+    /**
+     * <p>A string representing the starting point for the next set of revisions. If a
+     * value is returned in a response, you can retrieve the next set of revisions by
+     * providing the value in the <code>marker</code> parameter and retrying the
+     * command. If the <code>marker</code> field is empty, all revisions have already
+     * been returned.</p>
+     */
+    inline DescribeClusterDbRevisionsResult& WithMarker(const char* value) { SetMarker(value); return *this;}
+
+
+    /**
+     * <p>A list of revisions.</p>
+     */
+    inline const Aws::Vector<ClusterDbRevision>& GetClusterDbRevisions() const{ return m_clusterDbRevisions; }
+
+    /**
+     * <p>A list of revisions.</p>
+     */
+    inline void SetClusterDbRevisions(const Aws::Vector<ClusterDbRevision>& value) { m_clusterDbRevisions = value; }
+
+    /**
+     * <p>A list of revisions.</p>
+     */
+    inline void SetClusterDbRevisions(Aws::Vector<ClusterDbRevision>&& value) { m_clusterDbRevisions = std::move(value); }
+
+    /**
+     * <p>A list of revisions.</p>
+     */
+    inline DescribeClusterDbRevisionsResult& WithClusterDbRevisions(const Aws::Vector<ClusterDbRevision>& value) { SetClusterDbRevisions(value); return *this;}
+
+    /**
+     * <p>A list of revisions.</p>
+     */
+    inline DescribeClusterDbRevisionsResult& WithClusterDbRevisions(Aws::Vector<ClusterDbRevision>&& value) { SetClusterDbRevisions(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of revisions.</p>
+     */
+    inline DescribeClusterDbRevisionsResult& AddClusterDbRevisions(const ClusterDbRevision& value) { m_clusterDbRevisions.push_back(value); return *this; }
+
+    /**
+     * <p>A list of revisions.</p>
+     */
+    inline DescribeClusterDbRevisionsResult& AddClusterDbRevisions(ClusterDbRevision&& value) { m_clusterDbRevisions.push_back(std::move(value)); return *this; }
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline DescribeClusterDbRevisionsResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline DescribeClusterDbRevisionsResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_marker;
+
+    Aws::Vector<ClusterDbRevision> m_clusterDbRevisions;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DescribeClusterParameterGroupsRequest.h

@@ -0,0 +1,423 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p/><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/DescribeClusterParameterGroupsMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API DescribeClusterParameterGroupsRequest : public RedshiftRequest
+  {
+  public:
+    DescribeClusterParameterGroupsRequest();
+
+    // 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 "DescribeClusterParameterGroups"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The name of a specific parameter group for which to return details. By
+     * default, details about all parameter groups and the default parameter group are
+     * returned.</p>
+     */
+    inline const Aws::String& GetParameterGroupName() const{ return m_parameterGroupName; }
+
+    /**
+     * <p>The name of a specific parameter group for which to return details. By
+     * default, details about all parameter groups and the default parameter group are
+     * returned.</p>
+     */
+    inline bool ParameterGroupNameHasBeenSet() const { return m_parameterGroupNameHasBeenSet; }
+
+    /**
+     * <p>The name of a specific parameter group for which to return details. By
+     * default, details about all parameter groups and the default parameter group are
+     * returned.</p>
+     */
+    inline void SetParameterGroupName(const Aws::String& value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName = value; }
+
+    /**
+     * <p>The name of a specific parameter group for which to return details. By
+     * default, details about all parameter groups and the default parameter group are
+     * returned.</p>
+     */
+    inline void SetParameterGroupName(Aws::String&& value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName = std::move(value); }
+
+    /**
+     * <p>The name of a specific parameter group for which to return details. By
+     * default, details about all parameter groups and the default parameter group are
+     * returned.</p>
+     */
+    inline void SetParameterGroupName(const char* value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName.assign(value); }
+
+    /**
+     * <p>The name of a specific parameter group for which to return details. By
+     * default, details about all parameter groups and the default parameter group are
+     * returned.</p>
+     */
+    inline DescribeClusterParameterGroupsRequest& WithParameterGroupName(const Aws::String& value) { SetParameterGroupName(value); return *this;}
+
+    /**
+     * <p>The name of a specific parameter group for which to return details. By
+     * default, details about all parameter groups and the default parameter group are
+     * returned.</p>
+     */
+    inline DescribeClusterParameterGroupsRequest& WithParameterGroupName(Aws::String&& value) { SetParameterGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of a specific parameter group for which to return details. By
+     * default, details about all parameter groups and the default parameter group are
+     * returned.</p>
+     */
+    inline DescribeClusterParameterGroupsRequest& WithParameterGroupName(const char* value) { SetParameterGroupName(value); return *this;}
+
+
+    /**
+     * <p>The maximum number of response records to return in each call. If the number
+     * of remaining response records exceeds the specified <code>MaxRecords</code>
+     * value, a value is returned in a <code>marker</code> field of the response. You
+     * can retrieve the next set of records by retrying the command with the returned
+     * marker value. </p> <p>Default: <code>100</code> </p> <p>Constraints: minimum 20,
+     * maximum 100.</p>
+     */
+    inline int GetMaxRecords() const{ return m_maxRecords; }
+
+    /**
+     * <p>The maximum number of response records to return in each call. If the number
+     * of remaining response records exceeds the specified <code>MaxRecords</code>
+     * value, a value is returned in a <code>marker</code> field of the response. You
+     * can retrieve the next set of records by retrying the command with the returned
+     * marker value. </p> <p>Default: <code>100</code> </p> <p>Constraints: minimum 20,
+     * maximum 100.</p>
+     */
+    inline bool MaxRecordsHasBeenSet() const { return m_maxRecordsHasBeenSet; }
+
+    /**
+     * <p>The maximum number of response records to return in each call. If the number
+     * of remaining response records exceeds the specified <code>MaxRecords</code>
+     * value, a value is returned in a <code>marker</code> field of the response. You
+     * can retrieve the next set of records by retrying the command with the returned
+     * marker value. </p> <p>Default: <code>100</code> </p> <p>Constraints: minimum 20,
+     * maximum 100.</p>
+     */
+    inline void SetMaxRecords(int value) { m_maxRecordsHasBeenSet = true; m_maxRecords = value; }
+
+    /**
+     * <p>The maximum number of response records to return in each call. If the number
+     * of remaining response records exceeds the specified <code>MaxRecords</code>
+     * value, a value is returned in a <code>marker</code> field of the response. You
+     * can retrieve the next set of records by retrying the command with the returned
+     * marker value. </p> <p>Default: <code>100</code> </p> <p>Constraints: minimum 20,
+     * maximum 100.</p>
+     */
+    inline DescribeClusterParameterGroupsRequest& WithMaxRecords(int value) { SetMaxRecords(value); return *this;}
+
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterParameterGroups</a>
+     * request exceed the value specified in <code>MaxRecords</code>, AWS returns a
+     * value in the <code>Marker</code> field of the response. You can retrieve the
+     * next set of response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline const Aws::String& GetMarker() const{ return m_marker; }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterParameterGroups</a>
+     * request exceed the value specified in <code>MaxRecords</code>, AWS returns a
+     * value in the <code>Marker</code> field of the response. You can retrieve the
+     * next set of response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline bool MarkerHasBeenSet() const { return m_markerHasBeenSet; }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterParameterGroups</a>
+     * request exceed the value specified in <code>MaxRecords</code>, AWS returns a
+     * value in the <code>Marker</code> field of the response. You can retrieve the
+     * next set of response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline void SetMarker(const Aws::String& value) { m_markerHasBeenSet = true; m_marker = value; }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterParameterGroups</a>
+     * request exceed the value specified in <code>MaxRecords</code>, AWS returns a
+     * value in the <code>Marker</code> field of the response. You can retrieve the
+     * next set of response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline void SetMarker(Aws::String&& value) { m_markerHasBeenSet = true; m_marker = std::move(value); }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterParameterGroups</a>
+     * request exceed the value specified in <code>MaxRecords</code>, AWS returns a
+     * value in the <code>Marker</code> field of the response. You can retrieve the
+     * next set of response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline void SetMarker(const char* value) { m_markerHasBeenSet = true; m_marker.assign(value); }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterParameterGroups</a>
+     * request exceed the value specified in <code>MaxRecords</code>, AWS returns a
+     * value in the <code>Marker</code> field of the response. You can retrieve the
+     * next set of response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline DescribeClusterParameterGroupsRequest& WithMarker(const Aws::String& value) { SetMarker(value); return *this;}
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterParameterGroups</a>
+     * request exceed the value specified in <code>MaxRecords</code>, AWS returns a
+     * value in the <code>Marker</code> field of the response. You can retrieve the
+     * next set of response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline DescribeClusterParameterGroupsRequest& WithMarker(Aws::String&& value) { SetMarker(std::move(value)); return *this;}
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterParameterGroups</a>
+     * request exceed the value specified in <code>MaxRecords</code>, AWS returns a
+     * value in the <code>Marker</code> field of the response. You can retrieve the
+     * next set of response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline DescribeClusterParameterGroupsRequest& WithMarker(const char* value) { SetMarker(value); return *this;}
+
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster parameter
+     * groups that are associated with the specified key or keys. For example, suppose
+     * that you have parameter groups that are tagged with keys called
+     * <code>owner</code> and <code>environment</code>. If you specify both of these
+     * tag keys in the request, Amazon Redshift returns a response with the parameter
+     * groups that have either or both of these tag keys associated with them.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetTagKeys() const{ return m_tagKeys; }
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster parameter
+     * groups that are associated with the specified key or keys. For example, suppose
+     * that you have parameter groups that are tagged with keys called
+     * <code>owner</code> and <code>environment</code>. If you specify both of these
+     * tag keys in the request, Amazon Redshift returns a response with the parameter
+     * groups that have either or both of these tag keys associated with them.</p>
+     */
+    inline bool TagKeysHasBeenSet() const { return m_tagKeysHasBeenSet; }
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster parameter
+     * groups that are associated with the specified key or keys. For example, suppose
+     * that you have parameter groups that are tagged with keys called
+     * <code>owner</code> and <code>environment</code>. If you specify both of these
+     * tag keys in the request, Amazon Redshift returns a response with the parameter
+     * groups that have either or both of these tag keys associated with them.</p>
+     */
+    inline void SetTagKeys(const Aws::Vector<Aws::String>& value) { m_tagKeysHasBeenSet = true; m_tagKeys = value; }
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster parameter
+     * groups that are associated with the specified key or keys. For example, suppose
+     * that you have parameter groups that are tagged with keys called
+     * <code>owner</code> and <code>environment</code>. If you specify both of these
+     * tag keys in the request, Amazon Redshift returns a response with the parameter
+     * groups that have either or both of these tag keys associated with them.</p>
+     */
+    inline void SetTagKeys(Aws::Vector<Aws::String>&& value) { m_tagKeysHasBeenSet = true; m_tagKeys = std::move(value); }
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster parameter
+     * groups that are associated with the specified key or keys. For example, suppose
+     * that you have parameter groups that are tagged with keys called
+     * <code>owner</code> and <code>environment</code>. If you specify both of these
+     * tag keys in the request, Amazon Redshift returns a response with the parameter
+     * groups that have either or both of these tag keys associated with them.</p>
+     */
+    inline DescribeClusterParameterGroupsRequest& WithTagKeys(const Aws::Vector<Aws::String>& value) { SetTagKeys(value); return *this;}
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster parameter
+     * groups that are associated with the specified key or keys. For example, suppose
+     * that you have parameter groups that are tagged with keys called
+     * <code>owner</code> and <code>environment</code>. If you specify both of these
+     * tag keys in the request, Amazon Redshift returns a response with the parameter
+     * groups that have either or both of these tag keys associated with them.</p>
+     */
+    inline DescribeClusterParameterGroupsRequest& WithTagKeys(Aws::Vector<Aws::String>&& value) { SetTagKeys(std::move(value)); return *this;}
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster parameter
+     * groups that are associated with the specified key or keys. For example, suppose
+     * that you have parameter groups that are tagged with keys called
+     * <code>owner</code> and <code>environment</code>. If you specify both of these
+     * tag keys in the request, Amazon Redshift returns a response with the parameter
+     * groups that have either or both of these tag keys associated with them.</p>
+     */
+    inline DescribeClusterParameterGroupsRequest& AddTagKeys(const Aws::String& value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(value); return *this; }
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster parameter
+     * groups that are associated with the specified key or keys. For example, suppose
+     * that you have parameter groups that are tagged with keys called
+     * <code>owner</code> and <code>environment</code>. If you specify both of these
+     * tag keys in the request, Amazon Redshift returns a response with the parameter
+     * groups that have either or both of these tag keys associated with them.</p>
+     */
+    inline DescribeClusterParameterGroupsRequest& AddTagKeys(Aws::String&& value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster parameter
+     * groups that are associated with the specified key or keys. For example, suppose
+     * that you have parameter groups that are tagged with keys called
+     * <code>owner</code> and <code>environment</code>. If you specify both of these
+     * tag keys in the request, Amazon Redshift returns a response with the parameter
+     * groups that have either or both of these tag keys associated with them.</p>
+     */
+    inline DescribeClusterParameterGroupsRequest& AddTagKeys(const char* value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(value); return *this; }
+
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * parameter groups that are associated with the specified tag value or values. For
+     * example, suppose that you have parameter groups that are tagged with values
+     * called <code>admin</code> and <code>test</code>. If you specify both of these
+     * tag values in the request, Amazon Redshift returns a response with the parameter
+     * groups that have either or both of these tag values associated with them.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetTagValues() const{ return m_tagValues; }
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * parameter groups that are associated with the specified tag value or values. For
+     * example, suppose that you have parameter groups that are tagged with values
+     * called <code>admin</code> and <code>test</code>. If you specify both of these
+     * tag values in the request, Amazon Redshift returns a response with the parameter
+     * groups that have either or both of these tag values associated with them.</p>
+     */
+    inline bool TagValuesHasBeenSet() const { return m_tagValuesHasBeenSet; }
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * parameter groups that are associated with the specified tag value or values. For
+     * example, suppose that you have parameter groups that are tagged with values
+     * called <code>admin</code> and <code>test</code>. If you specify both of these
+     * tag values in the request, Amazon Redshift returns a response with the parameter
+     * groups that have either or both of these tag values associated with them.</p>
+     */
+    inline void SetTagValues(const Aws::Vector<Aws::String>& value) { m_tagValuesHasBeenSet = true; m_tagValues = value; }
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * parameter groups that are associated with the specified tag value or values. For
+     * example, suppose that you have parameter groups that are tagged with values
+     * called <code>admin</code> and <code>test</code>. If you specify both of these
+     * tag values in the request, Amazon Redshift returns a response with the parameter
+     * groups that have either or both of these tag values associated with them.</p>
+     */
+    inline void SetTagValues(Aws::Vector<Aws::String>&& value) { m_tagValuesHasBeenSet = true; m_tagValues = std::move(value); }
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * parameter groups that are associated with the specified tag value or values. For
+     * example, suppose that you have parameter groups that are tagged with values
+     * called <code>admin</code> and <code>test</code>. If you specify both of these
+     * tag values in the request, Amazon Redshift returns a response with the parameter
+     * groups that have either or both of these tag values associated with them.</p>
+     */
+    inline DescribeClusterParameterGroupsRequest& WithTagValues(const Aws::Vector<Aws::String>& value) { SetTagValues(value); return *this;}
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * parameter groups that are associated with the specified tag value or values. For
+     * example, suppose that you have parameter groups that are tagged with values
+     * called <code>admin</code> and <code>test</code>. If you specify both of these
+     * tag values in the request, Amazon Redshift returns a response with the parameter
+     * groups that have either or both of these tag values associated with them.</p>
+     */
+    inline DescribeClusterParameterGroupsRequest& WithTagValues(Aws::Vector<Aws::String>&& value) { SetTagValues(std::move(value)); return *this;}
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * parameter groups that are associated with the specified tag value or values. For
+     * example, suppose that you have parameter groups that are tagged with values
+     * called <code>admin</code> and <code>test</code>. If you specify both of these
+     * tag values in the request, Amazon Redshift returns a response with the parameter
+     * groups that have either or both of these tag values associated with them.</p>
+     */
+    inline DescribeClusterParameterGroupsRequest& AddTagValues(const Aws::String& value) { m_tagValuesHasBeenSet = true; m_tagValues.push_back(value); return *this; }
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * parameter groups that are associated with the specified tag value or values. For
+     * example, suppose that you have parameter groups that are tagged with values
+     * called <code>admin</code> and <code>test</code>. If you specify both of these
+     * tag values in the request, Amazon Redshift returns a response with the parameter
+     * groups that have either or both of these tag values associated with them.</p>
+     */
+    inline DescribeClusterParameterGroupsRequest& AddTagValues(Aws::String&& value) { m_tagValuesHasBeenSet = true; m_tagValues.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * parameter groups that are associated with the specified tag value or values. For
+     * example, suppose that you have parameter groups that are tagged with values
+     * called <code>admin</code> and <code>test</code>. If you specify both of these
+     * tag values in the request, Amazon Redshift returns a response with the parameter
+     * groups that have either or both of these tag values associated with them.</p>
+     */
+    inline DescribeClusterParameterGroupsRequest& AddTagValues(const char* value) { m_tagValuesHasBeenSet = true; m_tagValues.push_back(value); return *this; }
+
+  private:
+
+    Aws::String m_parameterGroupName;
+    bool m_parameterGroupNameHasBeenSet;
+
+    int m_maxRecords;
+    bool m_maxRecordsHasBeenSet;
+
+    Aws::String m_marker;
+    bool m_markerHasBeenSet;
+
+    Aws::Vector<Aws::String> m_tagKeys;
+    bool m_tagKeysHasBeenSet;
+
+    Aws::Vector<Aws::String> m_tagValues;
+    bool m_tagValuesHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DescribeClusterParameterGroupsResult.h

@@ -0,0 +1,184 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <aws/redshift/model/ClusterParameterGroup.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  /**
+   * <p>Contains the output from the <a>DescribeClusterParameterGroups</a> action.
+   * </p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/ClusterParameterGroupsMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API DescribeClusterParameterGroupsResult
+  {
+  public:
+    DescribeClusterParameterGroupsResult();
+    DescribeClusterParameterGroupsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    DescribeClusterParameterGroupsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline const Aws::String& GetMarker() const{ return m_marker; }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline void SetMarker(const Aws::String& value) { m_marker = value; }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline void SetMarker(Aws::String&& value) { m_marker = std::move(value); }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline void SetMarker(const char* value) { m_marker.assign(value); }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline DescribeClusterParameterGroupsResult& WithMarker(const Aws::String& value) { SetMarker(value); return *this;}
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline DescribeClusterParameterGroupsResult& WithMarker(Aws::String&& value) { SetMarker(std::move(value)); return *this;}
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline DescribeClusterParameterGroupsResult& WithMarker(const char* value) { SetMarker(value); return *this;}
+
+
+    /**
+     * <p>A list of <a>ClusterParameterGroup</a> instances. Each instance describes one
+     * cluster parameter group. </p>
+     */
+    inline const Aws::Vector<ClusterParameterGroup>& GetParameterGroups() const{ return m_parameterGroups; }
+
+    /**
+     * <p>A list of <a>ClusterParameterGroup</a> instances. Each instance describes one
+     * cluster parameter group. </p>
+     */
+    inline void SetParameterGroups(const Aws::Vector<ClusterParameterGroup>& value) { m_parameterGroups = value; }
+
+    /**
+     * <p>A list of <a>ClusterParameterGroup</a> instances. Each instance describes one
+     * cluster parameter group. </p>
+     */
+    inline void SetParameterGroups(Aws::Vector<ClusterParameterGroup>&& value) { m_parameterGroups = std::move(value); }
+
+    /**
+     * <p>A list of <a>ClusterParameterGroup</a> instances. Each instance describes one
+     * cluster parameter group. </p>
+     */
+    inline DescribeClusterParameterGroupsResult& WithParameterGroups(const Aws::Vector<ClusterParameterGroup>& value) { SetParameterGroups(value); return *this;}
+
+    /**
+     * <p>A list of <a>ClusterParameterGroup</a> instances. Each instance describes one
+     * cluster parameter group. </p>
+     */
+    inline DescribeClusterParameterGroupsResult& WithParameterGroups(Aws::Vector<ClusterParameterGroup>&& value) { SetParameterGroups(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of <a>ClusterParameterGroup</a> instances. Each instance describes one
+     * cluster parameter group. </p>
+     */
+    inline DescribeClusterParameterGroupsResult& AddParameterGroups(const ClusterParameterGroup& value) { m_parameterGroups.push_back(value); return *this; }
+
+    /**
+     * <p>A list of <a>ClusterParameterGroup</a> instances. Each instance describes one
+     * cluster parameter group. </p>
+     */
+    inline DescribeClusterParameterGroupsResult& AddParameterGroups(ClusterParameterGroup&& value) { m_parameterGroups.push_back(std::move(value)); return *this; }
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline DescribeClusterParameterGroupsResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline DescribeClusterParameterGroupsResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_marker;
+
+    Aws::Vector<ClusterParameterGroup> m_parameterGroups;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DescribeClusterParametersRequest.h

@@ -0,0 +1,294 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p/><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/DescribeClusterParametersMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API DescribeClusterParametersRequest : public RedshiftRequest
+  {
+  public:
+    DescribeClusterParametersRequest();
+
+    // 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 "DescribeClusterParameters"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The name of a cluster parameter group for which to return details.</p>
+     */
+    inline const Aws::String& GetParameterGroupName() const{ return m_parameterGroupName; }
+
+    /**
+     * <p>The name of a cluster parameter group for which to return details.</p>
+     */
+    inline bool ParameterGroupNameHasBeenSet() const { return m_parameterGroupNameHasBeenSet; }
+
+    /**
+     * <p>The name of a cluster parameter group for which to return details.</p>
+     */
+    inline void SetParameterGroupName(const Aws::String& value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName = value; }
+
+    /**
+     * <p>The name of a cluster parameter group for which to return details.</p>
+     */
+    inline void SetParameterGroupName(Aws::String&& value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName = std::move(value); }
+
+    /**
+     * <p>The name of a cluster parameter group for which to return details.</p>
+     */
+    inline void SetParameterGroupName(const char* value) { m_parameterGroupNameHasBeenSet = true; m_parameterGroupName.assign(value); }
+
+    /**
+     * <p>The name of a cluster parameter group for which to return details.</p>
+     */
+    inline DescribeClusterParametersRequest& WithParameterGroupName(const Aws::String& value) { SetParameterGroupName(value); return *this;}
+
+    /**
+     * <p>The name of a cluster parameter group for which to return details.</p>
+     */
+    inline DescribeClusterParametersRequest& WithParameterGroupName(Aws::String&& value) { SetParameterGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of a cluster parameter group for which to return details.</p>
+     */
+    inline DescribeClusterParametersRequest& WithParameterGroupName(const char* value) { SetParameterGroupName(value); return *this;}
+
+
+    /**
+     * <p>The parameter types to return. Specify <code>user</code> to show parameters
+     * that are different form the default. Similarly, specify
+     * <code>engine-default</code> to show parameters that are the same as the default
+     * parameter group. </p> <p>Default: All parameter types returned.</p> <p>Valid
+     * Values: <code>user</code> | <code>engine-default</code> </p>
+     */
+    inline const Aws::String& GetSource() const{ return m_source; }
+
+    /**
+     * <p>The parameter types to return. Specify <code>user</code> to show parameters
+     * that are different form the default. Similarly, specify
+     * <code>engine-default</code> to show parameters that are the same as the default
+     * parameter group. </p> <p>Default: All parameter types returned.</p> <p>Valid
+     * Values: <code>user</code> | <code>engine-default</code> </p>
+     */
+    inline bool SourceHasBeenSet() const { return m_sourceHasBeenSet; }
+
+    /**
+     * <p>The parameter types to return. Specify <code>user</code> to show parameters
+     * that are different form the default. Similarly, specify
+     * <code>engine-default</code> to show parameters that are the same as the default
+     * parameter group. </p> <p>Default: All parameter types returned.</p> <p>Valid
+     * Values: <code>user</code> | <code>engine-default</code> </p>
+     */
+    inline void SetSource(const Aws::String& value) { m_sourceHasBeenSet = true; m_source = value; }
+
+    /**
+     * <p>The parameter types to return. Specify <code>user</code> to show parameters
+     * that are different form the default. Similarly, specify
+     * <code>engine-default</code> to show parameters that are the same as the default
+     * parameter group. </p> <p>Default: All parameter types returned.</p> <p>Valid
+     * Values: <code>user</code> | <code>engine-default</code> </p>
+     */
+    inline void SetSource(Aws::String&& value) { m_sourceHasBeenSet = true; m_source = std::move(value); }
+
+    /**
+     * <p>The parameter types to return. Specify <code>user</code> to show parameters
+     * that are different form the default. Similarly, specify
+     * <code>engine-default</code> to show parameters that are the same as the default
+     * parameter group. </p> <p>Default: All parameter types returned.</p> <p>Valid
+     * Values: <code>user</code> | <code>engine-default</code> </p>
+     */
+    inline void SetSource(const char* value) { m_sourceHasBeenSet = true; m_source.assign(value); }
+
+    /**
+     * <p>The parameter types to return. Specify <code>user</code> to show parameters
+     * that are different form the default. Similarly, specify
+     * <code>engine-default</code> to show parameters that are the same as the default
+     * parameter group. </p> <p>Default: All parameter types returned.</p> <p>Valid
+     * Values: <code>user</code> | <code>engine-default</code> </p>
+     */
+    inline DescribeClusterParametersRequest& WithSource(const Aws::String& value) { SetSource(value); return *this;}
+
+    /**
+     * <p>The parameter types to return. Specify <code>user</code> to show parameters
+     * that are different form the default. Similarly, specify
+     * <code>engine-default</code> to show parameters that are the same as the default
+     * parameter group. </p> <p>Default: All parameter types returned.</p> <p>Valid
+     * Values: <code>user</code> | <code>engine-default</code> </p>
+     */
+    inline DescribeClusterParametersRequest& WithSource(Aws::String&& value) { SetSource(std::move(value)); return *this;}
+
+    /**
+     * <p>The parameter types to return. Specify <code>user</code> to show parameters
+     * that are different form the default. Similarly, specify
+     * <code>engine-default</code> to show parameters that are the same as the default
+     * parameter group. </p> <p>Default: All parameter types returned.</p> <p>Valid
+     * Values: <code>user</code> | <code>engine-default</code> </p>
+     */
+    inline DescribeClusterParametersRequest& WithSource(const char* value) { SetSource(value); return *this;}
+
+
+    /**
+     * <p>The maximum number of response records to return in each call. If the number
+     * of remaining response records exceeds the specified <code>MaxRecords</code>
+     * value, a value is returned in a <code>marker</code> field of the response. You
+     * can retrieve the next set of records by retrying the command with the returned
+     * marker value. </p> <p>Default: <code>100</code> </p> <p>Constraints: minimum 20,
+     * maximum 100.</p>
+     */
+    inline int GetMaxRecords() const{ return m_maxRecords; }
+
+    /**
+     * <p>The maximum number of response records to return in each call. If the number
+     * of remaining response records exceeds the specified <code>MaxRecords</code>
+     * value, a value is returned in a <code>marker</code> field of the response. You
+     * can retrieve the next set of records by retrying the command with the returned
+     * marker value. </p> <p>Default: <code>100</code> </p> <p>Constraints: minimum 20,
+     * maximum 100.</p>
+     */
+    inline bool MaxRecordsHasBeenSet() const { return m_maxRecordsHasBeenSet; }
+
+    /**
+     * <p>The maximum number of response records to return in each call. If the number
+     * of remaining response records exceeds the specified <code>MaxRecords</code>
+     * value, a value is returned in a <code>marker</code> field of the response. You
+     * can retrieve the next set of records by retrying the command with the returned
+     * marker value. </p> <p>Default: <code>100</code> </p> <p>Constraints: minimum 20,
+     * maximum 100.</p>
+     */
+    inline void SetMaxRecords(int value) { m_maxRecordsHasBeenSet = true; m_maxRecords = value; }
+
+    /**
+     * <p>The maximum number of response records to return in each call. If the number
+     * of remaining response records exceeds the specified <code>MaxRecords</code>
+     * value, a value is returned in a <code>marker</code> field of the response. You
+     * can retrieve the next set of records by retrying the command with the returned
+     * marker value. </p> <p>Default: <code>100</code> </p> <p>Constraints: minimum 20,
+     * maximum 100.</p>
+     */
+    inline DescribeClusterParametersRequest& WithMaxRecords(int value) { SetMaxRecords(value); return *this;}
+
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterParameters</a> request
+     * exceed the value specified in <code>MaxRecords</code>, AWS returns a value in
+     * the <code>Marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline const Aws::String& GetMarker() const{ return m_marker; }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterParameters</a> request
+     * exceed the value specified in <code>MaxRecords</code>, AWS returns a value in
+     * the <code>Marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline bool MarkerHasBeenSet() const { return m_markerHasBeenSet; }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterParameters</a> request
+     * exceed the value specified in <code>MaxRecords</code>, AWS returns a value in
+     * the <code>Marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline void SetMarker(const Aws::String& value) { m_markerHasBeenSet = true; m_marker = value; }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterParameters</a> request
+     * exceed the value specified in <code>MaxRecords</code>, AWS returns a value in
+     * the <code>Marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline void SetMarker(Aws::String&& value) { m_markerHasBeenSet = true; m_marker = std::move(value); }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterParameters</a> request
+     * exceed the value specified in <code>MaxRecords</code>, AWS returns a value in
+     * the <code>Marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline void SetMarker(const char* value) { m_markerHasBeenSet = true; m_marker.assign(value); }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterParameters</a> request
+     * exceed the value specified in <code>MaxRecords</code>, AWS returns a value in
+     * the <code>Marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline DescribeClusterParametersRequest& WithMarker(const Aws::String& value) { SetMarker(value); return *this;}
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterParameters</a> request
+     * exceed the value specified in <code>MaxRecords</code>, AWS returns a value in
+     * the <code>Marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline DescribeClusterParametersRequest& WithMarker(Aws::String&& value) { SetMarker(std::move(value)); return *this;}
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterParameters</a> request
+     * exceed the value specified in <code>MaxRecords</code>, AWS returns a value in
+     * the <code>Marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline DescribeClusterParametersRequest& WithMarker(const char* value) { SetMarker(value); return *this;}
+
+  private:
+
+    Aws::String m_parameterGroupName;
+    bool m_parameterGroupNameHasBeenSet;
+
+    Aws::String m_source;
+    bool m_sourceHasBeenSet;
+
+    int m_maxRecords;
+    bool m_maxRecordsHasBeenSet;
+
+    Aws::String m_marker;
+    bool m_markerHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DescribeClusterParametersResult.h

@@ -0,0 +1,184 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <aws/redshift/model/Parameter.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  /**
+   * <p>Contains the output from the <a>DescribeClusterParameters</a> action.
+   * </p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/ClusterParameterGroupDetails">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API DescribeClusterParametersResult
+  {
+  public:
+    DescribeClusterParametersResult();
+    DescribeClusterParametersResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    DescribeClusterParametersResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    /**
+     * <p>A list of <a>Parameter</a> instances. Each instance lists the parameters of
+     * one cluster parameter group. </p>
+     */
+    inline const Aws::Vector<Parameter>& GetParameters() const{ return m_parameters; }
+
+    /**
+     * <p>A list of <a>Parameter</a> instances. Each instance lists the parameters of
+     * one cluster parameter group. </p>
+     */
+    inline void SetParameters(const Aws::Vector<Parameter>& value) { m_parameters = value; }
+
+    /**
+     * <p>A list of <a>Parameter</a> instances. Each instance lists the parameters of
+     * one cluster parameter group. </p>
+     */
+    inline void SetParameters(Aws::Vector<Parameter>&& value) { m_parameters = std::move(value); }
+
+    /**
+     * <p>A list of <a>Parameter</a> instances. Each instance lists the parameters of
+     * one cluster parameter group. </p>
+     */
+    inline DescribeClusterParametersResult& WithParameters(const Aws::Vector<Parameter>& value) { SetParameters(value); return *this;}
+
+    /**
+     * <p>A list of <a>Parameter</a> instances. Each instance lists the parameters of
+     * one cluster parameter group. </p>
+     */
+    inline DescribeClusterParametersResult& WithParameters(Aws::Vector<Parameter>&& value) { SetParameters(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of <a>Parameter</a> instances. Each instance lists the parameters of
+     * one cluster parameter group. </p>
+     */
+    inline DescribeClusterParametersResult& AddParameters(const Parameter& value) { m_parameters.push_back(value); return *this; }
+
+    /**
+     * <p>A list of <a>Parameter</a> instances. Each instance lists the parameters of
+     * one cluster parameter group. </p>
+     */
+    inline DescribeClusterParametersResult& AddParameters(Parameter&& value) { m_parameters.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline const Aws::String& GetMarker() const{ return m_marker; }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline void SetMarker(const Aws::String& value) { m_marker = value; }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline void SetMarker(Aws::String&& value) { m_marker = std::move(value); }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline void SetMarker(const char* value) { m_marker.assign(value); }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline DescribeClusterParametersResult& WithMarker(const Aws::String& value) { SetMarker(value); return *this;}
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline DescribeClusterParametersResult& WithMarker(Aws::String&& value) { SetMarker(std::move(value)); return *this;}
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline DescribeClusterParametersResult& WithMarker(const char* value) { SetMarker(value); return *this;}
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline DescribeClusterParametersResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline DescribeClusterParametersResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    Aws::Vector<Parameter> m_parameters;
+
+    Aws::String m_marker;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DescribeClusterSecurityGroupsRequest.h

@@ -0,0 +1,447 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p/><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/DescribeClusterSecurityGroupsMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API DescribeClusterSecurityGroupsRequest : public RedshiftRequest
+  {
+  public:
+    DescribeClusterSecurityGroupsRequest();
+
+    // 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 "DescribeClusterSecurityGroups"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The name of a cluster security group for which you are requesting details.
+     * You can specify either the <b>Marker</b> parameter or a
+     * <b>ClusterSecurityGroupName</b> parameter, but not both. </p> <p> Example:
+     * <code>securitygroup1</code> </p>
+     */
+    inline const Aws::String& GetClusterSecurityGroupName() const{ return m_clusterSecurityGroupName; }
+
+    /**
+     * <p>The name of a cluster security group for which you are requesting details.
+     * You can specify either the <b>Marker</b> parameter or a
+     * <b>ClusterSecurityGroupName</b> parameter, but not both. </p> <p> Example:
+     * <code>securitygroup1</code> </p>
+     */
+    inline bool ClusterSecurityGroupNameHasBeenSet() const { return m_clusterSecurityGroupNameHasBeenSet; }
+
+    /**
+     * <p>The name of a cluster security group for which you are requesting details.
+     * You can specify either the <b>Marker</b> parameter or a
+     * <b>ClusterSecurityGroupName</b> parameter, but not both. </p> <p> Example:
+     * <code>securitygroup1</code> </p>
+     */
+    inline void SetClusterSecurityGroupName(const Aws::String& value) { m_clusterSecurityGroupNameHasBeenSet = true; m_clusterSecurityGroupName = value; }
+
+    /**
+     * <p>The name of a cluster security group for which you are requesting details.
+     * You can specify either the <b>Marker</b> parameter or a
+     * <b>ClusterSecurityGroupName</b> parameter, but not both. </p> <p> Example:
+     * <code>securitygroup1</code> </p>
+     */
+    inline void SetClusterSecurityGroupName(Aws::String&& value) { m_clusterSecurityGroupNameHasBeenSet = true; m_clusterSecurityGroupName = std::move(value); }
+
+    /**
+     * <p>The name of a cluster security group for which you are requesting details.
+     * You can specify either the <b>Marker</b> parameter or a
+     * <b>ClusterSecurityGroupName</b> parameter, but not both. </p> <p> Example:
+     * <code>securitygroup1</code> </p>
+     */
+    inline void SetClusterSecurityGroupName(const char* value) { m_clusterSecurityGroupNameHasBeenSet = true; m_clusterSecurityGroupName.assign(value); }
+
+    /**
+     * <p>The name of a cluster security group for which you are requesting details.
+     * You can specify either the <b>Marker</b> parameter or a
+     * <b>ClusterSecurityGroupName</b> parameter, but not both. </p> <p> Example:
+     * <code>securitygroup1</code> </p>
+     */
+    inline DescribeClusterSecurityGroupsRequest& WithClusterSecurityGroupName(const Aws::String& value) { SetClusterSecurityGroupName(value); return *this;}
+
+    /**
+     * <p>The name of a cluster security group for which you are requesting details.
+     * You can specify either the <b>Marker</b> parameter or a
+     * <b>ClusterSecurityGroupName</b> parameter, but not both. </p> <p> Example:
+     * <code>securitygroup1</code> </p>
+     */
+    inline DescribeClusterSecurityGroupsRequest& WithClusterSecurityGroupName(Aws::String&& value) { SetClusterSecurityGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of a cluster security group for which you are requesting details.
+     * You can specify either the <b>Marker</b> parameter or a
+     * <b>ClusterSecurityGroupName</b> parameter, but not both. </p> <p> Example:
+     * <code>securitygroup1</code> </p>
+     */
+    inline DescribeClusterSecurityGroupsRequest& WithClusterSecurityGroupName(const char* value) { SetClusterSecurityGroupName(value); return *this;}
+
+
+    /**
+     * <p>The maximum number of response records to return in each call. If the number
+     * of remaining response records exceeds the specified <code>MaxRecords</code>
+     * value, a value is returned in a <code>marker</code> field of the response. You
+     * can retrieve the next set of records by retrying the command with the returned
+     * marker value. </p> <p>Default: <code>100</code> </p> <p>Constraints: minimum 20,
+     * maximum 100.</p>
+     */
+    inline int GetMaxRecords() const{ return m_maxRecords; }
+
+    /**
+     * <p>The maximum number of response records to return in each call. If the number
+     * of remaining response records exceeds the specified <code>MaxRecords</code>
+     * value, a value is returned in a <code>marker</code> field of the response. You
+     * can retrieve the next set of records by retrying the command with the returned
+     * marker value. </p> <p>Default: <code>100</code> </p> <p>Constraints: minimum 20,
+     * maximum 100.</p>
+     */
+    inline bool MaxRecordsHasBeenSet() const { return m_maxRecordsHasBeenSet; }
+
+    /**
+     * <p>The maximum number of response records to return in each call. If the number
+     * of remaining response records exceeds the specified <code>MaxRecords</code>
+     * value, a value is returned in a <code>marker</code> field of the response. You
+     * can retrieve the next set of records by retrying the command with the returned
+     * marker value. </p> <p>Default: <code>100</code> </p> <p>Constraints: minimum 20,
+     * maximum 100.</p>
+     */
+    inline void SetMaxRecords(int value) { m_maxRecordsHasBeenSet = true; m_maxRecords = value; }
+
+    /**
+     * <p>The maximum number of response records to return in each call. If the number
+     * of remaining response records exceeds the specified <code>MaxRecords</code>
+     * value, a value is returned in a <code>marker</code> field of the response. You
+     * can retrieve the next set of records by retrying the command with the returned
+     * marker value. </p> <p>Default: <code>100</code> </p> <p>Constraints: minimum 20,
+     * maximum 100.</p>
+     */
+    inline DescribeClusterSecurityGroupsRequest& WithMaxRecords(int value) { SetMaxRecords(value); return *this;}
+
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterSecurityGroups</a>
+     * request exceed the value specified in <code>MaxRecords</code>, AWS returns a
+     * value in the <code>Marker</code> field of the response. You can retrieve the
+     * next set of response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p> <p>Constraints: You
+     * can specify either the <b>ClusterSecurityGroupName</b> parameter or the
+     * <b>Marker</b> parameter, but not both. </p>
+     */
+    inline const Aws::String& GetMarker() const{ return m_marker; }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterSecurityGroups</a>
+     * request exceed the value specified in <code>MaxRecords</code>, AWS returns a
+     * value in the <code>Marker</code> field of the response. You can retrieve the
+     * next set of response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p> <p>Constraints: You
+     * can specify either the <b>ClusterSecurityGroupName</b> parameter or the
+     * <b>Marker</b> parameter, but not both. </p>
+     */
+    inline bool MarkerHasBeenSet() const { return m_markerHasBeenSet; }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterSecurityGroups</a>
+     * request exceed the value specified in <code>MaxRecords</code>, AWS returns a
+     * value in the <code>Marker</code> field of the response. You can retrieve the
+     * next set of response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p> <p>Constraints: You
+     * can specify either the <b>ClusterSecurityGroupName</b> parameter or the
+     * <b>Marker</b> parameter, but not both. </p>
+     */
+    inline void SetMarker(const Aws::String& value) { m_markerHasBeenSet = true; m_marker = value; }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterSecurityGroups</a>
+     * request exceed the value specified in <code>MaxRecords</code>, AWS returns a
+     * value in the <code>Marker</code> field of the response. You can retrieve the
+     * next set of response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p> <p>Constraints: You
+     * can specify either the <b>ClusterSecurityGroupName</b> parameter or the
+     * <b>Marker</b> parameter, but not both. </p>
+     */
+    inline void SetMarker(Aws::String&& value) { m_markerHasBeenSet = true; m_marker = std::move(value); }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterSecurityGroups</a>
+     * request exceed the value specified in <code>MaxRecords</code>, AWS returns a
+     * value in the <code>Marker</code> field of the response. You can retrieve the
+     * next set of response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p> <p>Constraints: You
+     * can specify either the <b>ClusterSecurityGroupName</b> parameter or the
+     * <b>Marker</b> parameter, but not both. </p>
+     */
+    inline void SetMarker(const char* value) { m_markerHasBeenSet = true; m_marker.assign(value); }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterSecurityGroups</a>
+     * request exceed the value specified in <code>MaxRecords</code>, AWS returns a
+     * value in the <code>Marker</code> field of the response. You can retrieve the
+     * next set of response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p> <p>Constraints: You
+     * can specify either the <b>ClusterSecurityGroupName</b> parameter or the
+     * <b>Marker</b> parameter, but not both. </p>
+     */
+    inline DescribeClusterSecurityGroupsRequest& WithMarker(const Aws::String& value) { SetMarker(value); return *this;}
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterSecurityGroups</a>
+     * request exceed the value specified in <code>MaxRecords</code>, AWS returns a
+     * value in the <code>Marker</code> field of the response. You can retrieve the
+     * next set of response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p> <p>Constraints: You
+     * can specify either the <b>ClusterSecurityGroupName</b> parameter or the
+     * <b>Marker</b> parameter, but not both. </p>
+     */
+    inline DescribeClusterSecurityGroupsRequest& WithMarker(Aws::String&& value) { SetMarker(std::move(value)); return *this;}
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterSecurityGroups</a>
+     * request exceed the value specified in <code>MaxRecords</code>, AWS returns a
+     * value in the <code>Marker</code> field of the response. You can retrieve the
+     * next set of response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p> <p>Constraints: You
+     * can specify either the <b>ClusterSecurityGroupName</b> parameter or the
+     * <b>Marker</b> parameter, but not both. </p>
+     */
+    inline DescribeClusterSecurityGroupsRequest& WithMarker(const char* value) { SetMarker(value); return *this;}
+
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster security
+     * groups that are associated with the specified key or keys. For example, suppose
+     * that you have security groups that are tagged with keys called
+     * <code>owner</code> and <code>environment</code>. If you specify both of these
+     * tag keys in the request, Amazon Redshift returns a response with the security
+     * groups that have either or both of these tag keys associated with them.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetTagKeys() const{ return m_tagKeys; }
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster security
+     * groups that are associated with the specified key or keys. For example, suppose
+     * that you have security groups that are tagged with keys called
+     * <code>owner</code> and <code>environment</code>. If you specify both of these
+     * tag keys in the request, Amazon Redshift returns a response with the security
+     * groups that have either or both of these tag keys associated with them.</p>
+     */
+    inline bool TagKeysHasBeenSet() const { return m_tagKeysHasBeenSet; }
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster security
+     * groups that are associated with the specified key or keys. For example, suppose
+     * that you have security groups that are tagged with keys called
+     * <code>owner</code> and <code>environment</code>. If you specify both of these
+     * tag keys in the request, Amazon Redshift returns a response with the security
+     * groups that have either or both of these tag keys associated with them.</p>
+     */
+    inline void SetTagKeys(const Aws::Vector<Aws::String>& value) { m_tagKeysHasBeenSet = true; m_tagKeys = value; }
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster security
+     * groups that are associated with the specified key or keys. For example, suppose
+     * that you have security groups that are tagged with keys called
+     * <code>owner</code> and <code>environment</code>. If you specify both of these
+     * tag keys in the request, Amazon Redshift returns a response with the security
+     * groups that have either or both of these tag keys associated with them.</p>
+     */
+    inline void SetTagKeys(Aws::Vector<Aws::String>&& value) { m_tagKeysHasBeenSet = true; m_tagKeys = std::move(value); }
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster security
+     * groups that are associated with the specified key or keys. For example, suppose
+     * that you have security groups that are tagged with keys called
+     * <code>owner</code> and <code>environment</code>. If you specify both of these
+     * tag keys in the request, Amazon Redshift returns a response with the security
+     * groups that have either or both of these tag keys associated with them.</p>
+     */
+    inline DescribeClusterSecurityGroupsRequest& WithTagKeys(const Aws::Vector<Aws::String>& value) { SetTagKeys(value); return *this;}
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster security
+     * groups that are associated with the specified key or keys. For example, suppose
+     * that you have security groups that are tagged with keys called
+     * <code>owner</code> and <code>environment</code>. If you specify both of these
+     * tag keys in the request, Amazon Redshift returns a response with the security
+     * groups that have either or both of these tag keys associated with them.</p>
+     */
+    inline DescribeClusterSecurityGroupsRequest& WithTagKeys(Aws::Vector<Aws::String>&& value) { SetTagKeys(std::move(value)); return *this;}
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster security
+     * groups that are associated with the specified key or keys. For example, suppose
+     * that you have security groups that are tagged with keys called
+     * <code>owner</code> and <code>environment</code>. If you specify both of these
+     * tag keys in the request, Amazon Redshift returns a response with the security
+     * groups that have either or both of these tag keys associated with them.</p>
+     */
+    inline DescribeClusterSecurityGroupsRequest& AddTagKeys(const Aws::String& value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(value); return *this; }
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster security
+     * groups that are associated with the specified key or keys. For example, suppose
+     * that you have security groups that are tagged with keys called
+     * <code>owner</code> and <code>environment</code>. If you specify both of these
+     * tag keys in the request, Amazon Redshift returns a response with the security
+     * groups that have either or both of these tag keys associated with them.</p>
+     */
+    inline DescribeClusterSecurityGroupsRequest& AddTagKeys(Aws::String&& value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster security
+     * groups that are associated with the specified key or keys. For example, suppose
+     * that you have security groups that are tagged with keys called
+     * <code>owner</code> and <code>environment</code>. If you specify both of these
+     * tag keys in the request, Amazon Redshift returns a response with the security
+     * groups that have either or both of these tag keys associated with them.</p>
+     */
+    inline DescribeClusterSecurityGroupsRequest& AddTagKeys(const char* value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(value); return *this; }
+
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * security groups that are associated with the specified tag value or values. For
+     * example, suppose that you have security groups that are tagged with values
+     * called <code>admin</code> and <code>test</code>. If you specify both of these
+     * tag values in the request, Amazon Redshift returns a response with the security
+     * groups that have either or both of these tag values associated with them.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetTagValues() const{ return m_tagValues; }
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * security groups that are associated with the specified tag value or values. For
+     * example, suppose that you have security groups that are tagged with values
+     * called <code>admin</code> and <code>test</code>. If you specify both of these
+     * tag values in the request, Amazon Redshift returns a response with the security
+     * groups that have either or both of these tag values associated with them.</p>
+     */
+    inline bool TagValuesHasBeenSet() const { return m_tagValuesHasBeenSet; }
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * security groups that are associated with the specified tag value or values. For
+     * example, suppose that you have security groups that are tagged with values
+     * called <code>admin</code> and <code>test</code>. If you specify both of these
+     * tag values in the request, Amazon Redshift returns a response with the security
+     * groups that have either or both of these tag values associated with them.</p>
+     */
+    inline void SetTagValues(const Aws::Vector<Aws::String>& value) { m_tagValuesHasBeenSet = true; m_tagValues = value; }
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * security groups that are associated with the specified tag value or values. For
+     * example, suppose that you have security groups that are tagged with values
+     * called <code>admin</code> and <code>test</code>. If you specify both of these
+     * tag values in the request, Amazon Redshift returns a response with the security
+     * groups that have either or both of these tag values associated with them.</p>
+     */
+    inline void SetTagValues(Aws::Vector<Aws::String>&& value) { m_tagValuesHasBeenSet = true; m_tagValues = std::move(value); }
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * security groups that are associated with the specified tag value or values. For
+     * example, suppose that you have security groups that are tagged with values
+     * called <code>admin</code> and <code>test</code>. If you specify both of these
+     * tag values in the request, Amazon Redshift returns a response with the security
+     * groups that have either or both of these tag values associated with them.</p>
+     */
+    inline DescribeClusterSecurityGroupsRequest& WithTagValues(const Aws::Vector<Aws::String>& value) { SetTagValues(value); return *this;}
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * security groups that are associated with the specified tag value or values. For
+     * example, suppose that you have security groups that are tagged with values
+     * called <code>admin</code> and <code>test</code>. If you specify both of these
+     * tag values in the request, Amazon Redshift returns a response with the security
+     * groups that have either or both of these tag values associated with them.</p>
+     */
+    inline DescribeClusterSecurityGroupsRequest& WithTagValues(Aws::Vector<Aws::String>&& value) { SetTagValues(std::move(value)); return *this;}
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * security groups that are associated with the specified tag value or values. For
+     * example, suppose that you have security groups that are tagged with values
+     * called <code>admin</code> and <code>test</code>. If you specify both of these
+     * tag values in the request, Amazon Redshift returns a response with the security
+     * groups that have either or both of these tag values associated with them.</p>
+     */
+    inline DescribeClusterSecurityGroupsRequest& AddTagValues(const Aws::String& value) { m_tagValuesHasBeenSet = true; m_tagValues.push_back(value); return *this; }
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * security groups that are associated with the specified tag value or values. For
+     * example, suppose that you have security groups that are tagged with values
+     * called <code>admin</code> and <code>test</code>. If you specify both of these
+     * tag values in the request, Amazon Redshift returns a response with the security
+     * groups that have either or both of these tag values associated with them.</p>
+     */
+    inline DescribeClusterSecurityGroupsRequest& AddTagValues(Aws::String&& value) { m_tagValuesHasBeenSet = true; m_tagValues.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * security groups that are associated with the specified tag value or values. For
+     * example, suppose that you have security groups that are tagged with values
+     * called <code>admin</code> and <code>test</code>. If you specify both of these
+     * tag values in the request, Amazon Redshift returns a response with the security
+     * groups that have either or both of these tag values associated with them.</p>
+     */
+    inline DescribeClusterSecurityGroupsRequest& AddTagValues(const char* value) { m_tagValuesHasBeenSet = true; m_tagValues.push_back(value); return *this; }
+
+  private:
+
+    Aws::String m_clusterSecurityGroupName;
+    bool m_clusterSecurityGroupNameHasBeenSet;
+
+    int m_maxRecords;
+    bool m_maxRecordsHasBeenSet;
+
+    Aws::String m_marker;
+    bool m_markerHasBeenSet;
+
+    Aws::Vector<Aws::String> m_tagKeys;
+    bool m_tagKeysHasBeenSet;
+
+    Aws::Vector<Aws::String> m_tagValues;
+    bool m_tagValuesHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DescribeClusterSecurityGroupsResult.h

@@ -0,0 +1,176 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <aws/redshift/model/ClusterSecurityGroup.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  /**
+   * <p/><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/ClusterSecurityGroupMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API DescribeClusterSecurityGroupsResult
+  {
+  public:
+    DescribeClusterSecurityGroupsResult();
+    DescribeClusterSecurityGroupsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    DescribeClusterSecurityGroupsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline const Aws::String& GetMarker() const{ return m_marker; }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline void SetMarker(const Aws::String& value) { m_marker = value; }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline void SetMarker(Aws::String&& value) { m_marker = std::move(value); }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline void SetMarker(const char* value) { m_marker.assign(value); }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline DescribeClusterSecurityGroupsResult& WithMarker(const Aws::String& value) { SetMarker(value); return *this;}
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline DescribeClusterSecurityGroupsResult& WithMarker(Aws::String&& value) { SetMarker(std::move(value)); return *this;}
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline DescribeClusterSecurityGroupsResult& WithMarker(const char* value) { SetMarker(value); return *this;}
+
+
+    /**
+     * <p>A list of <a>ClusterSecurityGroup</a> instances. </p>
+     */
+    inline const Aws::Vector<ClusterSecurityGroup>& GetClusterSecurityGroups() const{ return m_clusterSecurityGroups; }
+
+    /**
+     * <p>A list of <a>ClusterSecurityGroup</a> instances. </p>
+     */
+    inline void SetClusterSecurityGroups(const Aws::Vector<ClusterSecurityGroup>& value) { m_clusterSecurityGroups = value; }
+
+    /**
+     * <p>A list of <a>ClusterSecurityGroup</a> instances. </p>
+     */
+    inline void SetClusterSecurityGroups(Aws::Vector<ClusterSecurityGroup>&& value) { m_clusterSecurityGroups = std::move(value); }
+
+    /**
+     * <p>A list of <a>ClusterSecurityGroup</a> instances. </p>
+     */
+    inline DescribeClusterSecurityGroupsResult& WithClusterSecurityGroups(const Aws::Vector<ClusterSecurityGroup>& value) { SetClusterSecurityGroups(value); return *this;}
+
+    /**
+     * <p>A list of <a>ClusterSecurityGroup</a> instances. </p>
+     */
+    inline DescribeClusterSecurityGroupsResult& WithClusterSecurityGroups(Aws::Vector<ClusterSecurityGroup>&& value) { SetClusterSecurityGroups(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of <a>ClusterSecurityGroup</a> instances. </p>
+     */
+    inline DescribeClusterSecurityGroupsResult& AddClusterSecurityGroups(const ClusterSecurityGroup& value) { m_clusterSecurityGroups.push_back(value); return *this; }
+
+    /**
+     * <p>A list of <a>ClusterSecurityGroup</a> instances. </p>
+     */
+    inline DescribeClusterSecurityGroupsResult& AddClusterSecurityGroups(ClusterSecurityGroup&& value) { m_clusterSecurityGroups.push_back(std::move(value)); return *this; }
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline DescribeClusterSecurityGroupsResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline DescribeClusterSecurityGroupsResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_marker;
+
+    Aws::Vector<ClusterSecurityGroup> m_clusterSecurityGroups;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DescribeClusterSnapshotsRequest.h

@@ -0,0 +1,813 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/DateTime.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/SnapshotSortingEntity.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p/><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/DescribeClusterSnapshotsMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API DescribeClusterSnapshotsRequest : public RedshiftRequest
+  {
+  public:
+    DescribeClusterSnapshotsRequest();
+
+    // 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 "DescribeClusterSnapshots"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The identifier of the cluster which generated the requested snapshots.</p>
+     */
+    inline const Aws::String& GetClusterIdentifier() const{ return m_clusterIdentifier; }
+
+    /**
+     * <p>The identifier of the cluster which generated the requested snapshots.</p>
+     */
+    inline bool ClusterIdentifierHasBeenSet() const { return m_clusterIdentifierHasBeenSet; }
+
+    /**
+     * <p>The identifier of the cluster which generated the requested snapshots.</p>
+     */
+    inline void SetClusterIdentifier(const Aws::String& value) { m_clusterIdentifierHasBeenSet = true; m_clusterIdentifier = value; }
+
+    /**
+     * <p>The identifier of the cluster which generated the requested snapshots.</p>
+     */
+    inline void SetClusterIdentifier(Aws::String&& value) { m_clusterIdentifierHasBeenSet = true; m_clusterIdentifier = std::move(value); }
+
+    /**
+     * <p>The identifier of the cluster which generated the requested snapshots.</p>
+     */
+    inline void SetClusterIdentifier(const char* value) { m_clusterIdentifierHasBeenSet = true; m_clusterIdentifier.assign(value); }
+
+    /**
+     * <p>The identifier of the cluster which generated the requested snapshots.</p>
+     */
+    inline DescribeClusterSnapshotsRequest& WithClusterIdentifier(const Aws::String& value) { SetClusterIdentifier(value); return *this;}
+
+    /**
+     * <p>The identifier of the cluster which generated the requested snapshots.</p>
+     */
+    inline DescribeClusterSnapshotsRequest& WithClusterIdentifier(Aws::String&& value) { SetClusterIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>The identifier of the cluster which generated the requested snapshots.</p>
+     */
+    inline DescribeClusterSnapshotsRequest& WithClusterIdentifier(const char* value) { SetClusterIdentifier(value); return *this;}
+
+
+    /**
+     * <p>The snapshot identifier of the snapshot about which to return
+     * information.</p>
+     */
+    inline const Aws::String& GetSnapshotIdentifier() const{ return m_snapshotIdentifier; }
+
+    /**
+     * <p>The snapshot identifier of the snapshot about which to return
+     * information.</p>
+     */
+    inline bool SnapshotIdentifierHasBeenSet() const { return m_snapshotIdentifierHasBeenSet; }
+
+    /**
+     * <p>The snapshot identifier of the snapshot about which to return
+     * information.</p>
+     */
+    inline void SetSnapshotIdentifier(const Aws::String& value) { m_snapshotIdentifierHasBeenSet = true; m_snapshotIdentifier = value; }
+
+    /**
+     * <p>The snapshot identifier of the snapshot about which to return
+     * information.</p>
+     */
+    inline void SetSnapshotIdentifier(Aws::String&& value) { m_snapshotIdentifierHasBeenSet = true; m_snapshotIdentifier = std::move(value); }
+
+    /**
+     * <p>The snapshot identifier of the snapshot about which to return
+     * information.</p>
+     */
+    inline void SetSnapshotIdentifier(const char* value) { m_snapshotIdentifierHasBeenSet = true; m_snapshotIdentifier.assign(value); }
+
+    /**
+     * <p>The snapshot identifier of the snapshot about which to return
+     * information.</p>
+     */
+    inline DescribeClusterSnapshotsRequest& WithSnapshotIdentifier(const Aws::String& value) { SetSnapshotIdentifier(value); return *this;}
+
+    /**
+     * <p>The snapshot identifier of the snapshot about which to return
+     * information.</p>
+     */
+    inline DescribeClusterSnapshotsRequest& WithSnapshotIdentifier(Aws::String&& value) { SetSnapshotIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>The snapshot identifier of the snapshot about which to return
+     * information.</p>
+     */
+    inline DescribeClusterSnapshotsRequest& WithSnapshotIdentifier(const char* value) { SetSnapshotIdentifier(value); return *this;}
+
+
+    /**
+     * <p>The type of snapshots for which you are requesting information. By default,
+     * snapshots of all types are returned.</p> <p>Valid Values: <code>automated</code>
+     * | <code>manual</code> </p>
+     */
+    inline const Aws::String& GetSnapshotType() const{ return m_snapshotType; }
+
+    /**
+     * <p>The type of snapshots for which you are requesting information. By default,
+     * snapshots of all types are returned.</p> <p>Valid Values: <code>automated</code>
+     * | <code>manual</code> </p>
+     */
+    inline bool SnapshotTypeHasBeenSet() const { return m_snapshotTypeHasBeenSet; }
+
+    /**
+     * <p>The type of snapshots for which you are requesting information. By default,
+     * snapshots of all types are returned.</p> <p>Valid Values: <code>automated</code>
+     * | <code>manual</code> </p>
+     */
+    inline void SetSnapshotType(const Aws::String& value) { m_snapshotTypeHasBeenSet = true; m_snapshotType = value; }
+
+    /**
+     * <p>The type of snapshots for which you are requesting information. By default,
+     * snapshots of all types are returned.</p> <p>Valid Values: <code>automated</code>
+     * | <code>manual</code> </p>
+     */
+    inline void SetSnapshotType(Aws::String&& value) { m_snapshotTypeHasBeenSet = true; m_snapshotType = std::move(value); }
+
+    /**
+     * <p>The type of snapshots for which you are requesting information. By default,
+     * snapshots of all types are returned.</p> <p>Valid Values: <code>automated</code>
+     * | <code>manual</code> </p>
+     */
+    inline void SetSnapshotType(const char* value) { m_snapshotTypeHasBeenSet = true; m_snapshotType.assign(value); }
+
+    /**
+     * <p>The type of snapshots for which you are requesting information. By default,
+     * snapshots of all types are returned.</p> <p>Valid Values: <code>automated</code>
+     * | <code>manual</code> </p>
+     */
+    inline DescribeClusterSnapshotsRequest& WithSnapshotType(const Aws::String& value) { SetSnapshotType(value); return *this;}
+
+    /**
+     * <p>The type of snapshots for which you are requesting information. By default,
+     * snapshots of all types are returned.</p> <p>Valid Values: <code>automated</code>
+     * | <code>manual</code> </p>
+     */
+    inline DescribeClusterSnapshotsRequest& WithSnapshotType(Aws::String&& value) { SetSnapshotType(std::move(value)); return *this;}
+
+    /**
+     * <p>The type of snapshots for which you are requesting information. By default,
+     * snapshots of all types are returned.</p> <p>Valid Values: <code>automated</code>
+     * | <code>manual</code> </p>
+     */
+    inline DescribeClusterSnapshotsRequest& WithSnapshotType(const char* value) { SetSnapshotType(value); return *this;}
+
+
+    /**
+     * <p>A value that requests only snapshots created at or after the specified time.
+     * The time value is specified in ISO 8601 format. For more information about ISO
+     * 8601, go to the <a href="http://en.wikipedia.org/wiki/ISO_8601">ISO8601
+     * Wikipedia page.</a> </p> <p>Example: <code>2012-07-16T18:00:00Z</code> </p>
+     */
+    inline const Aws::Utils::DateTime& GetStartTime() const{ return m_startTime; }
+
+    /**
+     * <p>A value that requests only snapshots created at or after the specified time.
+     * The time value is specified in ISO 8601 format. For more information about ISO
+     * 8601, go to the <a href="http://en.wikipedia.org/wiki/ISO_8601">ISO8601
+     * Wikipedia page.</a> </p> <p>Example: <code>2012-07-16T18:00:00Z</code> </p>
+     */
+    inline bool StartTimeHasBeenSet() const { return m_startTimeHasBeenSet; }
+
+    /**
+     * <p>A value that requests only snapshots created at or after the specified time.
+     * The time value is specified in ISO 8601 format. For more information about ISO
+     * 8601, go to the <a href="http://en.wikipedia.org/wiki/ISO_8601">ISO8601
+     * Wikipedia page.</a> </p> <p>Example: <code>2012-07-16T18:00:00Z</code> </p>
+     */
+    inline void SetStartTime(const Aws::Utils::DateTime& value) { m_startTimeHasBeenSet = true; m_startTime = value; }
+
+    /**
+     * <p>A value that requests only snapshots created at or after the specified time.
+     * The time value is specified in ISO 8601 format. For more information about ISO
+     * 8601, go to the <a href="http://en.wikipedia.org/wiki/ISO_8601">ISO8601
+     * Wikipedia page.</a> </p> <p>Example: <code>2012-07-16T18:00:00Z</code> </p>
+     */
+    inline void SetStartTime(Aws::Utils::DateTime&& value) { m_startTimeHasBeenSet = true; m_startTime = std::move(value); }
+
+    /**
+     * <p>A value that requests only snapshots created at or after the specified time.
+     * The time value is specified in ISO 8601 format. For more information about ISO
+     * 8601, go to the <a href="http://en.wikipedia.org/wiki/ISO_8601">ISO8601
+     * Wikipedia page.</a> </p> <p>Example: <code>2012-07-16T18:00:00Z</code> </p>
+     */
+    inline DescribeClusterSnapshotsRequest& WithStartTime(const Aws::Utils::DateTime& value) { SetStartTime(value); return *this;}
+
+    /**
+     * <p>A value that requests only snapshots created at or after the specified time.
+     * The time value is specified in ISO 8601 format. For more information about ISO
+     * 8601, go to the <a href="http://en.wikipedia.org/wiki/ISO_8601">ISO8601
+     * Wikipedia page.</a> </p> <p>Example: <code>2012-07-16T18:00:00Z</code> </p>
+     */
+    inline DescribeClusterSnapshotsRequest& WithStartTime(Aws::Utils::DateTime&& value) { SetStartTime(std::move(value)); return *this;}
+
+
+    /**
+     * <p>A time value that requests only snapshots created at or before the specified
+     * time. The time value is specified in ISO 8601 format. For more information about
+     * ISO 8601, go to the <a href="http://en.wikipedia.org/wiki/ISO_8601">ISO8601
+     * Wikipedia page.</a> </p> <p>Example: <code>2012-07-16T18:00:00Z</code> </p>
+     */
+    inline const Aws::Utils::DateTime& GetEndTime() const{ return m_endTime; }
+
+    /**
+     * <p>A time value that requests only snapshots created at or before the specified
+     * time. The time value is specified in ISO 8601 format. For more information about
+     * ISO 8601, go to the <a href="http://en.wikipedia.org/wiki/ISO_8601">ISO8601
+     * Wikipedia page.</a> </p> <p>Example: <code>2012-07-16T18:00:00Z</code> </p>
+     */
+    inline bool EndTimeHasBeenSet() const { return m_endTimeHasBeenSet; }
+
+    /**
+     * <p>A time value that requests only snapshots created at or before the specified
+     * time. The time value is specified in ISO 8601 format. For more information about
+     * ISO 8601, go to the <a href="http://en.wikipedia.org/wiki/ISO_8601">ISO8601
+     * Wikipedia page.</a> </p> <p>Example: <code>2012-07-16T18:00:00Z</code> </p>
+     */
+    inline void SetEndTime(const Aws::Utils::DateTime& value) { m_endTimeHasBeenSet = true; m_endTime = value; }
+
+    /**
+     * <p>A time value that requests only snapshots created at or before the specified
+     * time. The time value is specified in ISO 8601 format. For more information about
+     * ISO 8601, go to the <a href="http://en.wikipedia.org/wiki/ISO_8601">ISO8601
+     * Wikipedia page.</a> </p> <p>Example: <code>2012-07-16T18:00:00Z</code> </p>
+     */
+    inline void SetEndTime(Aws::Utils::DateTime&& value) { m_endTimeHasBeenSet = true; m_endTime = std::move(value); }
+
+    /**
+     * <p>A time value that requests only snapshots created at or before the specified
+     * time. The time value is specified in ISO 8601 format. For more information about
+     * ISO 8601, go to the <a href="http://en.wikipedia.org/wiki/ISO_8601">ISO8601
+     * Wikipedia page.</a> </p> <p>Example: <code>2012-07-16T18:00:00Z</code> </p>
+     */
+    inline DescribeClusterSnapshotsRequest& WithEndTime(const Aws::Utils::DateTime& value) { SetEndTime(value); return *this;}
+
+    /**
+     * <p>A time value that requests only snapshots created at or before the specified
+     * time. The time value is specified in ISO 8601 format. For more information about
+     * ISO 8601, go to the <a href="http://en.wikipedia.org/wiki/ISO_8601">ISO8601
+     * Wikipedia page.</a> </p> <p>Example: <code>2012-07-16T18:00:00Z</code> </p>
+     */
+    inline DescribeClusterSnapshotsRequest& WithEndTime(Aws::Utils::DateTime&& value) { SetEndTime(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The maximum number of response records to return in each call. If the number
+     * of remaining response records exceeds the specified <code>MaxRecords</code>
+     * value, a value is returned in a <code>marker</code> field of the response. You
+     * can retrieve the next set of records by retrying the command with the returned
+     * marker value. </p> <p>Default: <code>100</code> </p> <p>Constraints: minimum 20,
+     * maximum 100.</p>
+     */
+    inline int GetMaxRecords() const{ return m_maxRecords; }
+
+    /**
+     * <p>The maximum number of response records to return in each call. If the number
+     * of remaining response records exceeds the specified <code>MaxRecords</code>
+     * value, a value is returned in a <code>marker</code> field of the response. You
+     * can retrieve the next set of records by retrying the command with the returned
+     * marker value. </p> <p>Default: <code>100</code> </p> <p>Constraints: minimum 20,
+     * maximum 100.</p>
+     */
+    inline bool MaxRecordsHasBeenSet() const { return m_maxRecordsHasBeenSet; }
+
+    /**
+     * <p>The maximum number of response records to return in each call. If the number
+     * of remaining response records exceeds the specified <code>MaxRecords</code>
+     * value, a value is returned in a <code>marker</code> field of the response. You
+     * can retrieve the next set of records by retrying the command with the returned
+     * marker value. </p> <p>Default: <code>100</code> </p> <p>Constraints: minimum 20,
+     * maximum 100.</p>
+     */
+    inline void SetMaxRecords(int value) { m_maxRecordsHasBeenSet = true; m_maxRecords = value; }
+
+    /**
+     * <p>The maximum number of response records to return in each call. If the number
+     * of remaining response records exceeds the specified <code>MaxRecords</code>
+     * value, a value is returned in a <code>marker</code> field of the response. You
+     * can retrieve the next set of records by retrying the command with the returned
+     * marker value. </p> <p>Default: <code>100</code> </p> <p>Constraints: minimum 20,
+     * maximum 100.</p>
+     */
+    inline DescribeClusterSnapshotsRequest& WithMaxRecords(int value) { SetMaxRecords(value); return *this;}
+
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterSnapshots</a> request
+     * exceed the value specified in <code>MaxRecords</code>, AWS returns a value in
+     * the <code>Marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline const Aws::String& GetMarker() const{ return m_marker; }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterSnapshots</a> request
+     * exceed the value specified in <code>MaxRecords</code>, AWS returns a value in
+     * the <code>Marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline bool MarkerHasBeenSet() const { return m_markerHasBeenSet; }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterSnapshots</a> request
+     * exceed the value specified in <code>MaxRecords</code>, AWS returns a value in
+     * the <code>Marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline void SetMarker(const Aws::String& value) { m_markerHasBeenSet = true; m_marker = value; }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterSnapshots</a> request
+     * exceed the value specified in <code>MaxRecords</code>, AWS returns a value in
+     * the <code>Marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline void SetMarker(Aws::String&& value) { m_markerHasBeenSet = true; m_marker = std::move(value); }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterSnapshots</a> request
+     * exceed the value specified in <code>MaxRecords</code>, AWS returns a value in
+     * the <code>Marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline void SetMarker(const char* value) { m_markerHasBeenSet = true; m_marker.assign(value); }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterSnapshots</a> request
+     * exceed the value specified in <code>MaxRecords</code>, AWS returns a value in
+     * the <code>Marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline DescribeClusterSnapshotsRequest& WithMarker(const Aws::String& value) { SetMarker(value); return *this;}
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterSnapshots</a> request
+     * exceed the value specified in <code>MaxRecords</code>, AWS returns a value in
+     * the <code>Marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline DescribeClusterSnapshotsRequest& WithMarker(Aws::String&& value) { SetMarker(std::move(value)); return *this;}
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterSnapshots</a> request
+     * exceed the value specified in <code>MaxRecords</code>, AWS returns a value in
+     * the <code>Marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline DescribeClusterSnapshotsRequest& WithMarker(const char* value) { SetMarker(value); return *this;}
+
+
+    /**
+     * <p>The AWS customer account used to create or copy the snapshot. Use this field
+     * to filter the results to snapshots owned by a particular account. To describe
+     * snapshots you own, either specify your AWS customer account, or do not specify
+     * the parameter.</p>
+     */
+    inline const Aws::String& GetOwnerAccount() const{ return m_ownerAccount; }
+
+    /**
+     * <p>The AWS customer account used to create or copy the snapshot. Use this field
+     * to filter the results to snapshots owned by a particular account. To describe
+     * snapshots you own, either specify your AWS customer account, or do not specify
+     * the parameter.</p>
+     */
+    inline bool OwnerAccountHasBeenSet() const { return m_ownerAccountHasBeenSet; }
+
+    /**
+     * <p>The AWS customer account used to create or copy the snapshot. Use this field
+     * to filter the results to snapshots owned by a particular account. To describe
+     * snapshots you own, either specify your AWS customer account, or do not specify
+     * the parameter.</p>
+     */
+    inline void SetOwnerAccount(const Aws::String& value) { m_ownerAccountHasBeenSet = true; m_ownerAccount = value; }
+
+    /**
+     * <p>The AWS customer account used to create or copy the snapshot. Use this field
+     * to filter the results to snapshots owned by a particular account. To describe
+     * snapshots you own, either specify your AWS customer account, or do not specify
+     * the parameter.</p>
+     */
+    inline void SetOwnerAccount(Aws::String&& value) { m_ownerAccountHasBeenSet = true; m_ownerAccount = std::move(value); }
+
+    /**
+     * <p>The AWS customer account used to create or copy the snapshot. Use this field
+     * to filter the results to snapshots owned by a particular account. To describe
+     * snapshots you own, either specify your AWS customer account, or do not specify
+     * the parameter.</p>
+     */
+    inline void SetOwnerAccount(const char* value) { m_ownerAccountHasBeenSet = true; m_ownerAccount.assign(value); }
+
+    /**
+     * <p>The AWS customer account used to create or copy the snapshot. Use this field
+     * to filter the results to snapshots owned by a particular account. To describe
+     * snapshots you own, either specify your AWS customer account, or do not specify
+     * the parameter.</p>
+     */
+    inline DescribeClusterSnapshotsRequest& WithOwnerAccount(const Aws::String& value) { SetOwnerAccount(value); return *this;}
+
+    /**
+     * <p>The AWS customer account used to create or copy the snapshot. Use this field
+     * to filter the results to snapshots owned by a particular account. To describe
+     * snapshots you own, either specify your AWS customer account, or do not specify
+     * the parameter.</p>
+     */
+    inline DescribeClusterSnapshotsRequest& WithOwnerAccount(Aws::String&& value) { SetOwnerAccount(std::move(value)); return *this;}
+
+    /**
+     * <p>The AWS customer account used to create or copy the snapshot. Use this field
+     * to filter the results to snapshots owned by a particular account. To describe
+     * snapshots you own, either specify your AWS customer account, or do not specify
+     * the parameter.</p>
+     */
+    inline DescribeClusterSnapshotsRequest& WithOwnerAccount(const char* value) { SetOwnerAccount(value); return *this;}
+
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster snapshots
+     * that are associated with the specified key or keys. For example, suppose that
+     * you have snapshots that are tagged with keys called <code>owner</code> and
+     * <code>environment</code>. If you specify both of these tag keys in the request,
+     * Amazon Redshift returns a response with the snapshots that have either or both
+     * of these tag keys associated with them.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetTagKeys() const{ return m_tagKeys; }
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster snapshots
+     * that are associated with the specified key or keys. For example, suppose that
+     * you have snapshots that are tagged with keys called <code>owner</code> and
+     * <code>environment</code>. If you specify both of these tag keys in the request,
+     * Amazon Redshift returns a response with the snapshots that have either or both
+     * of these tag keys associated with them.</p>
+     */
+    inline bool TagKeysHasBeenSet() const { return m_tagKeysHasBeenSet; }
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster snapshots
+     * that are associated with the specified key or keys. For example, suppose that
+     * you have snapshots that are tagged with keys called <code>owner</code> and
+     * <code>environment</code>. If you specify both of these tag keys in the request,
+     * Amazon Redshift returns a response with the snapshots that have either or both
+     * of these tag keys associated with them.</p>
+     */
+    inline void SetTagKeys(const Aws::Vector<Aws::String>& value) { m_tagKeysHasBeenSet = true; m_tagKeys = value; }
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster snapshots
+     * that are associated with the specified key or keys. For example, suppose that
+     * you have snapshots that are tagged with keys called <code>owner</code> and
+     * <code>environment</code>. If you specify both of these tag keys in the request,
+     * Amazon Redshift returns a response with the snapshots that have either or both
+     * of these tag keys associated with them.</p>
+     */
+    inline void SetTagKeys(Aws::Vector<Aws::String>&& value) { m_tagKeysHasBeenSet = true; m_tagKeys = std::move(value); }
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster snapshots
+     * that are associated with the specified key or keys. For example, suppose that
+     * you have snapshots that are tagged with keys called <code>owner</code> and
+     * <code>environment</code>. If you specify both of these tag keys in the request,
+     * Amazon Redshift returns a response with the snapshots that have either or both
+     * of these tag keys associated with them.</p>
+     */
+    inline DescribeClusterSnapshotsRequest& WithTagKeys(const Aws::Vector<Aws::String>& value) { SetTagKeys(value); return *this;}
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster snapshots
+     * that are associated with the specified key or keys. For example, suppose that
+     * you have snapshots that are tagged with keys called <code>owner</code> and
+     * <code>environment</code>. If you specify both of these tag keys in the request,
+     * Amazon Redshift returns a response with the snapshots that have either or both
+     * of these tag keys associated with them.</p>
+     */
+    inline DescribeClusterSnapshotsRequest& WithTagKeys(Aws::Vector<Aws::String>&& value) { SetTagKeys(std::move(value)); return *this;}
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster snapshots
+     * that are associated with the specified key or keys. For example, suppose that
+     * you have snapshots that are tagged with keys called <code>owner</code> and
+     * <code>environment</code>. If you specify both of these tag keys in the request,
+     * Amazon Redshift returns a response with the snapshots that have either or both
+     * of these tag keys associated with them.</p>
+     */
+    inline DescribeClusterSnapshotsRequest& AddTagKeys(const Aws::String& value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(value); return *this; }
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster snapshots
+     * that are associated with the specified key or keys. For example, suppose that
+     * you have snapshots that are tagged with keys called <code>owner</code> and
+     * <code>environment</code>. If you specify both of these tag keys in the request,
+     * Amazon Redshift returns a response with the snapshots that have either or both
+     * of these tag keys associated with them.</p>
+     */
+    inline DescribeClusterSnapshotsRequest& AddTagKeys(Aws::String&& value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster snapshots
+     * that are associated with the specified key or keys. For example, suppose that
+     * you have snapshots that are tagged with keys called <code>owner</code> and
+     * <code>environment</code>. If you specify both of these tag keys in the request,
+     * Amazon Redshift returns a response with the snapshots that have either or both
+     * of these tag keys associated with them.</p>
+     */
+    inline DescribeClusterSnapshotsRequest& AddTagKeys(const char* value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(value); return *this; }
+
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * snapshots that are associated with the specified tag value or values. For
+     * example, suppose that you have snapshots that are tagged with values called
+     * <code>admin</code> and <code>test</code>. If you specify both of these tag
+     * values in the request, Amazon Redshift returns a response with the snapshots
+     * that have either or both of these tag values associated with them.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetTagValues() const{ return m_tagValues; }
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * snapshots that are associated with the specified tag value or values. For
+     * example, suppose that you have snapshots that are tagged with values called
+     * <code>admin</code> and <code>test</code>. If you specify both of these tag
+     * values in the request, Amazon Redshift returns a response with the snapshots
+     * that have either or both of these tag values associated with them.</p>
+     */
+    inline bool TagValuesHasBeenSet() const { return m_tagValuesHasBeenSet; }
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * snapshots that are associated with the specified tag value or values. For
+     * example, suppose that you have snapshots that are tagged with values called
+     * <code>admin</code> and <code>test</code>. If you specify both of these tag
+     * values in the request, Amazon Redshift returns a response with the snapshots
+     * that have either or both of these tag values associated with them.</p>
+     */
+    inline void SetTagValues(const Aws::Vector<Aws::String>& value) { m_tagValuesHasBeenSet = true; m_tagValues = value; }
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * snapshots that are associated with the specified tag value or values. For
+     * example, suppose that you have snapshots that are tagged with values called
+     * <code>admin</code> and <code>test</code>. If you specify both of these tag
+     * values in the request, Amazon Redshift returns a response with the snapshots
+     * that have either or both of these tag values associated with them.</p>
+     */
+    inline void SetTagValues(Aws::Vector<Aws::String>&& value) { m_tagValuesHasBeenSet = true; m_tagValues = std::move(value); }
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * snapshots that are associated with the specified tag value or values. For
+     * example, suppose that you have snapshots that are tagged with values called
+     * <code>admin</code> and <code>test</code>. If you specify both of these tag
+     * values in the request, Amazon Redshift returns a response with the snapshots
+     * that have either or both of these tag values associated with them.</p>
+     */
+    inline DescribeClusterSnapshotsRequest& WithTagValues(const Aws::Vector<Aws::String>& value) { SetTagValues(value); return *this;}
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * snapshots that are associated with the specified tag value or values. For
+     * example, suppose that you have snapshots that are tagged with values called
+     * <code>admin</code> and <code>test</code>. If you specify both of these tag
+     * values in the request, Amazon Redshift returns a response with the snapshots
+     * that have either or both of these tag values associated with them.</p>
+     */
+    inline DescribeClusterSnapshotsRequest& WithTagValues(Aws::Vector<Aws::String>&& value) { SetTagValues(std::move(value)); return *this;}
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * snapshots that are associated with the specified tag value or values. For
+     * example, suppose that you have snapshots that are tagged with values called
+     * <code>admin</code> and <code>test</code>. If you specify both of these tag
+     * values in the request, Amazon Redshift returns a response with the snapshots
+     * that have either or both of these tag values associated with them.</p>
+     */
+    inline DescribeClusterSnapshotsRequest& AddTagValues(const Aws::String& value) { m_tagValuesHasBeenSet = true; m_tagValues.push_back(value); return *this; }
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * snapshots that are associated with the specified tag value or values. For
+     * example, suppose that you have snapshots that are tagged with values called
+     * <code>admin</code> and <code>test</code>. If you specify both of these tag
+     * values in the request, Amazon Redshift returns a response with the snapshots
+     * that have either or both of these tag values associated with them.</p>
+     */
+    inline DescribeClusterSnapshotsRequest& AddTagValues(Aws::String&& value) { m_tagValuesHasBeenSet = true; m_tagValues.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * snapshots that are associated with the specified tag value or values. For
+     * example, suppose that you have snapshots that are tagged with values called
+     * <code>admin</code> and <code>test</code>. If you specify both of these tag
+     * values in the request, Amazon Redshift returns a response with the snapshots
+     * that have either or both of these tag values associated with them.</p>
+     */
+    inline DescribeClusterSnapshotsRequest& AddTagValues(const char* value) { m_tagValuesHasBeenSet = true; m_tagValues.push_back(value); return *this; }
+
+
+    /**
+     * <p>A value that indicates whether to return snapshots only for an existing
+     * cluster. You can perform table-level restore only by using a snapshot of an
+     * existing cluster, that is, a cluster that has not been deleted. Values for this
+     * parameter work as follows: </p> <ul> <li> <p>If <code>ClusterExists</code> is
+     * set to <code>true</code>, <code>ClusterIdentifier</code> is required.</p> </li>
+     * <li> <p>If <code>ClusterExists</code> is set to <code>false</code> and
+     * <code>ClusterIdentifier</code> isn't specified, all snapshots associated with
+     * deleted clusters (orphaned snapshots) are returned. </p> </li> <li> <p>If
+     * <code>ClusterExists</code> is set to <code>false</code> and
+     * <code>ClusterIdentifier</code> is specified for a deleted cluster, snapshots
+     * associated with that cluster are returned.</p> </li> <li> <p>If
+     * <code>ClusterExists</code> is set to <code>false</code> and
+     * <code>ClusterIdentifier</code> is specified for an existing cluster, no
+     * snapshots are returned. </p> </li> </ul>
+     */
+    inline bool GetClusterExists() const{ return m_clusterExists; }
+
+    /**
+     * <p>A value that indicates whether to return snapshots only for an existing
+     * cluster. You can perform table-level restore only by using a snapshot of an
+     * existing cluster, that is, a cluster that has not been deleted. Values for this
+     * parameter work as follows: </p> <ul> <li> <p>If <code>ClusterExists</code> is
+     * set to <code>true</code>, <code>ClusterIdentifier</code> is required.</p> </li>
+     * <li> <p>If <code>ClusterExists</code> is set to <code>false</code> and
+     * <code>ClusterIdentifier</code> isn't specified, all snapshots associated with
+     * deleted clusters (orphaned snapshots) are returned. </p> </li> <li> <p>If
+     * <code>ClusterExists</code> is set to <code>false</code> and
+     * <code>ClusterIdentifier</code> is specified for a deleted cluster, snapshots
+     * associated with that cluster are returned.</p> </li> <li> <p>If
+     * <code>ClusterExists</code> is set to <code>false</code> and
+     * <code>ClusterIdentifier</code> is specified for an existing cluster, no
+     * snapshots are returned. </p> </li> </ul>
+     */
+    inline bool ClusterExistsHasBeenSet() const { return m_clusterExistsHasBeenSet; }
+
+    /**
+     * <p>A value that indicates whether to return snapshots only for an existing
+     * cluster. You can perform table-level restore only by using a snapshot of an
+     * existing cluster, that is, a cluster that has not been deleted. Values for this
+     * parameter work as follows: </p> <ul> <li> <p>If <code>ClusterExists</code> is
+     * set to <code>true</code>, <code>ClusterIdentifier</code> is required.</p> </li>
+     * <li> <p>If <code>ClusterExists</code> is set to <code>false</code> and
+     * <code>ClusterIdentifier</code> isn't specified, all snapshots associated with
+     * deleted clusters (orphaned snapshots) are returned. </p> </li> <li> <p>If
+     * <code>ClusterExists</code> is set to <code>false</code> and
+     * <code>ClusterIdentifier</code> is specified for a deleted cluster, snapshots
+     * associated with that cluster are returned.</p> </li> <li> <p>If
+     * <code>ClusterExists</code> is set to <code>false</code> and
+     * <code>ClusterIdentifier</code> is specified for an existing cluster, no
+     * snapshots are returned. </p> </li> </ul>
+     */
+    inline void SetClusterExists(bool value) { m_clusterExistsHasBeenSet = true; m_clusterExists = value; }
+
+    /**
+     * <p>A value that indicates whether to return snapshots only for an existing
+     * cluster. You can perform table-level restore only by using a snapshot of an
+     * existing cluster, that is, a cluster that has not been deleted. Values for this
+     * parameter work as follows: </p> <ul> <li> <p>If <code>ClusterExists</code> is
+     * set to <code>true</code>, <code>ClusterIdentifier</code> is required.</p> </li>
+     * <li> <p>If <code>ClusterExists</code> is set to <code>false</code> and
+     * <code>ClusterIdentifier</code> isn't specified, all snapshots associated with
+     * deleted clusters (orphaned snapshots) are returned. </p> </li> <li> <p>If
+     * <code>ClusterExists</code> is set to <code>false</code> and
+     * <code>ClusterIdentifier</code> is specified for a deleted cluster, snapshots
+     * associated with that cluster are returned.</p> </li> <li> <p>If
+     * <code>ClusterExists</code> is set to <code>false</code> and
+     * <code>ClusterIdentifier</code> is specified for an existing cluster, no
+     * snapshots are returned. </p> </li> </ul>
+     */
+    inline DescribeClusterSnapshotsRequest& WithClusterExists(bool value) { SetClusterExists(value); return *this;}
+
+
+    /**
+     * <p/>
+     */
+    inline const Aws::Vector<SnapshotSortingEntity>& GetSortingEntities() const{ return m_sortingEntities; }
+
+    /**
+     * <p/>
+     */
+    inline bool SortingEntitiesHasBeenSet() const { return m_sortingEntitiesHasBeenSet; }
+
+    /**
+     * <p/>
+     */
+    inline void SetSortingEntities(const Aws::Vector<SnapshotSortingEntity>& value) { m_sortingEntitiesHasBeenSet = true; m_sortingEntities = value; }
+
+    /**
+     * <p/>
+     */
+    inline void SetSortingEntities(Aws::Vector<SnapshotSortingEntity>&& value) { m_sortingEntitiesHasBeenSet = true; m_sortingEntities = std::move(value); }
+
+    /**
+     * <p/>
+     */
+    inline DescribeClusterSnapshotsRequest& WithSortingEntities(const Aws::Vector<SnapshotSortingEntity>& value) { SetSortingEntities(value); return *this;}
+
+    /**
+     * <p/>
+     */
+    inline DescribeClusterSnapshotsRequest& WithSortingEntities(Aws::Vector<SnapshotSortingEntity>&& value) { SetSortingEntities(std::move(value)); return *this;}
+
+    /**
+     * <p/>
+     */
+    inline DescribeClusterSnapshotsRequest& AddSortingEntities(const SnapshotSortingEntity& value) { m_sortingEntitiesHasBeenSet = true; m_sortingEntities.push_back(value); return *this; }
+
+    /**
+     * <p/>
+     */
+    inline DescribeClusterSnapshotsRequest& AddSortingEntities(SnapshotSortingEntity&& value) { m_sortingEntitiesHasBeenSet = true; m_sortingEntities.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_clusterIdentifier;
+    bool m_clusterIdentifierHasBeenSet;
+
+    Aws::String m_snapshotIdentifier;
+    bool m_snapshotIdentifierHasBeenSet;
+
+    Aws::String m_snapshotType;
+    bool m_snapshotTypeHasBeenSet;
+
+    Aws::Utils::DateTime m_startTime;
+    bool m_startTimeHasBeenSet;
+
+    Aws::Utils::DateTime m_endTime;
+    bool m_endTimeHasBeenSet;
+
+    int m_maxRecords;
+    bool m_maxRecordsHasBeenSet;
+
+    Aws::String m_marker;
+    bool m_markerHasBeenSet;
+
+    Aws::String m_ownerAccount;
+    bool m_ownerAccountHasBeenSet;
+
+    Aws::Vector<Aws::String> m_tagKeys;
+    bool m_tagKeysHasBeenSet;
+
+    Aws::Vector<Aws::String> m_tagValues;
+    bool m_tagValuesHasBeenSet;
+
+    bool m_clusterExists;
+    bool m_clusterExistsHasBeenSet;
+
+    Aws::Vector<SnapshotSortingEntity> m_sortingEntities;
+    bool m_sortingEntitiesHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DescribeClusterSnapshotsResult.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/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <aws/redshift/model/Snapshot.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  /**
+   * <p>Contains the output from the <a>DescribeClusterSnapshots</a> action.
+   * </p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/SnapshotMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API DescribeClusterSnapshotsResult
+  {
+  public:
+    DescribeClusterSnapshotsResult();
+    DescribeClusterSnapshotsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    DescribeClusterSnapshotsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline const Aws::String& GetMarker() const{ return m_marker; }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline void SetMarker(const Aws::String& value) { m_marker = value; }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline void SetMarker(Aws::String&& value) { m_marker = std::move(value); }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline void SetMarker(const char* value) { m_marker.assign(value); }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline DescribeClusterSnapshotsResult& WithMarker(const Aws::String& value) { SetMarker(value); return *this;}
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline DescribeClusterSnapshotsResult& WithMarker(Aws::String&& value) { SetMarker(std::move(value)); return *this;}
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline DescribeClusterSnapshotsResult& WithMarker(const char* value) { SetMarker(value); return *this;}
+
+
+    /**
+     * <p>A list of <a>Snapshot</a> instances. </p>
+     */
+    inline const Aws::Vector<Snapshot>& GetSnapshots() const{ return m_snapshots; }
+
+    /**
+     * <p>A list of <a>Snapshot</a> instances. </p>
+     */
+    inline void SetSnapshots(const Aws::Vector<Snapshot>& value) { m_snapshots = value; }
+
+    /**
+     * <p>A list of <a>Snapshot</a> instances. </p>
+     */
+    inline void SetSnapshots(Aws::Vector<Snapshot>&& value) { m_snapshots = std::move(value); }
+
+    /**
+     * <p>A list of <a>Snapshot</a> instances. </p>
+     */
+    inline DescribeClusterSnapshotsResult& WithSnapshots(const Aws::Vector<Snapshot>& value) { SetSnapshots(value); return *this;}
+
+    /**
+     * <p>A list of <a>Snapshot</a> instances. </p>
+     */
+    inline DescribeClusterSnapshotsResult& WithSnapshots(Aws::Vector<Snapshot>&& value) { SetSnapshots(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of <a>Snapshot</a> instances. </p>
+     */
+    inline DescribeClusterSnapshotsResult& AddSnapshots(const Snapshot& value) { m_snapshots.push_back(value); return *this; }
+
+    /**
+     * <p>A list of <a>Snapshot</a> instances. </p>
+     */
+    inline DescribeClusterSnapshotsResult& AddSnapshots(Snapshot&& value) { m_snapshots.push_back(std::move(value)); return *this; }
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline DescribeClusterSnapshotsResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline DescribeClusterSnapshotsResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_marker;
+
+    Aws::Vector<Snapshot> m_snapshots;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DescribeClusterSubnetGroupsRequest.h

@@ -0,0 +1,407 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p/><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/DescribeClusterSubnetGroupsMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API DescribeClusterSubnetGroupsRequest : public RedshiftRequest
+  {
+  public:
+    DescribeClusterSubnetGroupsRequest();
+
+    // 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 "DescribeClusterSubnetGroups"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The name of the cluster subnet group for which information is requested.</p>
+     */
+    inline const Aws::String& GetClusterSubnetGroupName() const{ return m_clusterSubnetGroupName; }
+
+    /**
+     * <p>The name of the cluster subnet group for which information is requested.</p>
+     */
+    inline bool ClusterSubnetGroupNameHasBeenSet() const { return m_clusterSubnetGroupNameHasBeenSet; }
+
+    /**
+     * <p>The name of the cluster subnet group for which information is requested.</p>
+     */
+    inline void SetClusterSubnetGroupName(const Aws::String& value) { m_clusterSubnetGroupNameHasBeenSet = true; m_clusterSubnetGroupName = value; }
+
+    /**
+     * <p>The name of the cluster subnet group for which information is requested.</p>
+     */
+    inline void SetClusterSubnetGroupName(Aws::String&& value) { m_clusterSubnetGroupNameHasBeenSet = true; m_clusterSubnetGroupName = std::move(value); }
+
+    /**
+     * <p>The name of the cluster subnet group for which information is requested.</p>
+     */
+    inline void SetClusterSubnetGroupName(const char* value) { m_clusterSubnetGroupNameHasBeenSet = true; m_clusterSubnetGroupName.assign(value); }
+
+    /**
+     * <p>The name of the cluster subnet group for which information is requested.</p>
+     */
+    inline DescribeClusterSubnetGroupsRequest& WithClusterSubnetGroupName(const Aws::String& value) { SetClusterSubnetGroupName(value); return *this;}
+
+    /**
+     * <p>The name of the cluster subnet group for which information is requested.</p>
+     */
+    inline DescribeClusterSubnetGroupsRequest& WithClusterSubnetGroupName(Aws::String&& value) { SetClusterSubnetGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the cluster subnet group for which information is requested.</p>
+     */
+    inline DescribeClusterSubnetGroupsRequest& WithClusterSubnetGroupName(const char* value) { SetClusterSubnetGroupName(value); return *this;}
+
+
+    /**
+     * <p>The maximum number of response records to return in each call. If the number
+     * of remaining response records exceeds the specified <code>MaxRecords</code>
+     * value, a value is returned in a <code>marker</code> field of the response. You
+     * can retrieve the next set of records by retrying the command with the returned
+     * marker value. </p> <p>Default: <code>100</code> </p> <p>Constraints: minimum 20,
+     * maximum 100.</p>
+     */
+    inline int GetMaxRecords() const{ return m_maxRecords; }
+
+    /**
+     * <p>The maximum number of response records to return in each call. If the number
+     * of remaining response records exceeds the specified <code>MaxRecords</code>
+     * value, a value is returned in a <code>marker</code> field of the response. You
+     * can retrieve the next set of records by retrying the command with the returned
+     * marker value. </p> <p>Default: <code>100</code> </p> <p>Constraints: minimum 20,
+     * maximum 100.</p>
+     */
+    inline bool MaxRecordsHasBeenSet() const { return m_maxRecordsHasBeenSet; }
+
+    /**
+     * <p>The maximum number of response records to return in each call. If the number
+     * of remaining response records exceeds the specified <code>MaxRecords</code>
+     * value, a value is returned in a <code>marker</code> field of the response. You
+     * can retrieve the next set of records by retrying the command with the returned
+     * marker value. </p> <p>Default: <code>100</code> </p> <p>Constraints: minimum 20,
+     * maximum 100.</p>
+     */
+    inline void SetMaxRecords(int value) { m_maxRecordsHasBeenSet = true; m_maxRecords = value; }
+
+    /**
+     * <p>The maximum number of response records to return in each call. If the number
+     * of remaining response records exceeds the specified <code>MaxRecords</code>
+     * value, a value is returned in a <code>marker</code> field of the response. You
+     * can retrieve the next set of records by retrying the command with the returned
+     * marker value. </p> <p>Default: <code>100</code> </p> <p>Constraints: minimum 20,
+     * maximum 100.</p>
+     */
+    inline DescribeClusterSubnetGroupsRequest& WithMaxRecords(int value) { SetMaxRecords(value); return *this;}
+
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterSubnetGroups</a>
+     * request exceed the value specified in <code>MaxRecords</code>, AWS returns a
+     * value in the <code>Marker</code> field of the response. You can retrieve the
+     * next set of response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline const Aws::String& GetMarker() const{ return m_marker; }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterSubnetGroups</a>
+     * request exceed the value specified in <code>MaxRecords</code>, AWS returns a
+     * value in the <code>Marker</code> field of the response. You can retrieve the
+     * next set of response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline bool MarkerHasBeenSet() const { return m_markerHasBeenSet; }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterSubnetGroups</a>
+     * request exceed the value specified in <code>MaxRecords</code>, AWS returns a
+     * value in the <code>Marker</code> field of the response. You can retrieve the
+     * next set of response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline void SetMarker(const Aws::String& value) { m_markerHasBeenSet = true; m_marker = value; }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterSubnetGroups</a>
+     * request exceed the value specified in <code>MaxRecords</code>, AWS returns a
+     * value in the <code>Marker</code> field of the response. You can retrieve the
+     * next set of response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline void SetMarker(Aws::String&& value) { m_markerHasBeenSet = true; m_marker = std::move(value); }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterSubnetGroups</a>
+     * request exceed the value specified in <code>MaxRecords</code>, AWS returns a
+     * value in the <code>Marker</code> field of the response. You can retrieve the
+     * next set of response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline void SetMarker(const char* value) { m_markerHasBeenSet = true; m_marker.assign(value); }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterSubnetGroups</a>
+     * request exceed the value specified in <code>MaxRecords</code>, AWS returns a
+     * value in the <code>Marker</code> field of the response. You can retrieve the
+     * next set of response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline DescribeClusterSubnetGroupsRequest& WithMarker(const Aws::String& value) { SetMarker(value); return *this;}
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterSubnetGroups</a>
+     * request exceed the value specified in <code>MaxRecords</code>, AWS returns a
+     * value in the <code>Marker</code> field of the response. You can retrieve the
+     * next set of response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline DescribeClusterSubnetGroupsRequest& WithMarker(Aws::String&& value) { SetMarker(std::move(value)); return *this;}
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterSubnetGroups</a>
+     * request exceed the value specified in <code>MaxRecords</code>, AWS returns a
+     * value in the <code>Marker</code> field of the response. You can retrieve the
+     * next set of response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline DescribeClusterSubnetGroupsRequest& WithMarker(const char* value) { SetMarker(value); return *this;}
+
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster subnet
+     * groups that are associated with the specified key or keys. For example, suppose
+     * that you have subnet groups that are tagged with keys called <code>owner</code>
+     * and <code>environment</code>. If you specify both of these tag keys in the
+     * request, Amazon Redshift returns a response with the subnet groups that have
+     * either or both of these tag keys associated with them.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetTagKeys() const{ return m_tagKeys; }
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster subnet
+     * groups that are associated with the specified key or keys. For example, suppose
+     * that you have subnet groups that are tagged with keys called <code>owner</code>
+     * and <code>environment</code>. If you specify both of these tag keys in the
+     * request, Amazon Redshift returns a response with the subnet groups that have
+     * either or both of these tag keys associated with them.</p>
+     */
+    inline bool TagKeysHasBeenSet() const { return m_tagKeysHasBeenSet; }
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster subnet
+     * groups that are associated with the specified key or keys. For example, suppose
+     * that you have subnet groups that are tagged with keys called <code>owner</code>
+     * and <code>environment</code>. If you specify both of these tag keys in the
+     * request, Amazon Redshift returns a response with the subnet groups that have
+     * either or both of these tag keys associated with them.</p>
+     */
+    inline void SetTagKeys(const Aws::Vector<Aws::String>& value) { m_tagKeysHasBeenSet = true; m_tagKeys = value; }
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster subnet
+     * groups that are associated with the specified key or keys. For example, suppose
+     * that you have subnet groups that are tagged with keys called <code>owner</code>
+     * and <code>environment</code>. If you specify both of these tag keys in the
+     * request, Amazon Redshift returns a response with the subnet groups that have
+     * either or both of these tag keys associated with them.</p>
+     */
+    inline void SetTagKeys(Aws::Vector<Aws::String>&& value) { m_tagKeysHasBeenSet = true; m_tagKeys = std::move(value); }
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster subnet
+     * groups that are associated with the specified key or keys. For example, suppose
+     * that you have subnet groups that are tagged with keys called <code>owner</code>
+     * and <code>environment</code>. If you specify both of these tag keys in the
+     * request, Amazon Redshift returns a response with the subnet groups that have
+     * either or both of these tag keys associated with them.</p>
+     */
+    inline DescribeClusterSubnetGroupsRequest& WithTagKeys(const Aws::Vector<Aws::String>& value) { SetTagKeys(value); return *this;}
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster subnet
+     * groups that are associated with the specified key or keys. For example, suppose
+     * that you have subnet groups that are tagged with keys called <code>owner</code>
+     * and <code>environment</code>. If you specify both of these tag keys in the
+     * request, Amazon Redshift returns a response with the subnet groups that have
+     * either or both of these tag keys associated with them.</p>
+     */
+    inline DescribeClusterSubnetGroupsRequest& WithTagKeys(Aws::Vector<Aws::String>&& value) { SetTagKeys(std::move(value)); return *this;}
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster subnet
+     * groups that are associated with the specified key or keys. For example, suppose
+     * that you have subnet groups that are tagged with keys called <code>owner</code>
+     * and <code>environment</code>. If you specify both of these tag keys in the
+     * request, Amazon Redshift returns a response with the subnet groups that have
+     * either or both of these tag keys associated with them.</p>
+     */
+    inline DescribeClusterSubnetGroupsRequest& AddTagKeys(const Aws::String& value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(value); return *this; }
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster subnet
+     * groups that are associated with the specified key or keys. For example, suppose
+     * that you have subnet groups that are tagged with keys called <code>owner</code>
+     * and <code>environment</code>. If you specify both of these tag keys in the
+     * request, Amazon Redshift returns a response with the subnet groups that have
+     * either or both of these tag keys associated with them.</p>
+     */
+    inline DescribeClusterSubnetGroupsRequest& AddTagKeys(Aws::String&& value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>A tag key or keys for which you want to return all matching cluster subnet
+     * groups that are associated with the specified key or keys. For example, suppose
+     * that you have subnet groups that are tagged with keys called <code>owner</code>
+     * and <code>environment</code>. If you specify both of these tag keys in the
+     * request, Amazon Redshift returns a response with the subnet groups that have
+     * either or both of these tag keys associated with them.</p>
+     */
+    inline DescribeClusterSubnetGroupsRequest& AddTagKeys(const char* value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(value); return *this; }
+
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * subnet groups that are associated with the specified tag value or values. For
+     * example, suppose that you have subnet groups that are tagged with values called
+     * <code>admin</code> and <code>test</code>. If you specify both of these tag
+     * values in the request, Amazon Redshift returns a response with the subnet groups
+     * that have either or both of these tag values associated with them.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetTagValues() const{ return m_tagValues; }
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * subnet groups that are associated with the specified tag value or values. For
+     * example, suppose that you have subnet groups that are tagged with values called
+     * <code>admin</code> and <code>test</code>. If you specify both of these tag
+     * values in the request, Amazon Redshift returns a response with the subnet groups
+     * that have either or both of these tag values associated with them.</p>
+     */
+    inline bool TagValuesHasBeenSet() const { return m_tagValuesHasBeenSet; }
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * subnet groups that are associated with the specified tag value or values. For
+     * example, suppose that you have subnet groups that are tagged with values called
+     * <code>admin</code> and <code>test</code>. If you specify both of these tag
+     * values in the request, Amazon Redshift returns a response with the subnet groups
+     * that have either or both of these tag values associated with them.</p>
+     */
+    inline void SetTagValues(const Aws::Vector<Aws::String>& value) { m_tagValuesHasBeenSet = true; m_tagValues = value; }
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * subnet groups that are associated with the specified tag value or values. For
+     * example, suppose that you have subnet groups that are tagged with values called
+     * <code>admin</code> and <code>test</code>. If you specify both of these tag
+     * values in the request, Amazon Redshift returns a response with the subnet groups
+     * that have either or both of these tag values associated with them.</p>
+     */
+    inline void SetTagValues(Aws::Vector<Aws::String>&& value) { m_tagValuesHasBeenSet = true; m_tagValues = std::move(value); }
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * subnet groups that are associated with the specified tag value or values. For
+     * example, suppose that you have subnet groups that are tagged with values called
+     * <code>admin</code> and <code>test</code>. If you specify both of these tag
+     * values in the request, Amazon Redshift returns a response with the subnet groups
+     * that have either or both of these tag values associated with them.</p>
+     */
+    inline DescribeClusterSubnetGroupsRequest& WithTagValues(const Aws::Vector<Aws::String>& value) { SetTagValues(value); return *this;}
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * subnet groups that are associated with the specified tag value or values. For
+     * example, suppose that you have subnet groups that are tagged with values called
+     * <code>admin</code> and <code>test</code>. If you specify both of these tag
+     * values in the request, Amazon Redshift returns a response with the subnet groups
+     * that have either or both of these tag values associated with them.</p>
+     */
+    inline DescribeClusterSubnetGroupsRequest& WithTagValues(Aws::Vector<Aws::String>&& value) { SetTagValues(std::move(value)); return *this;}
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * subnet groups that are associated with the specified tag value or values. For
+     * example, suppose that you have subnet groups that are tagged with values called
+     * <code>admin</code> and <code>test</code>. If you specify both of these tag
+     * values in the request, Amazon Redshift returns a response with the subnet groups
+     * that have either or both of these tag values associated with them.</p>
+     */
+    inline DescribeClusterSubnetGroupsRequest& AddTagValues(const Aws::String& value) { m_tagValuesHasBeenSet = true; m_tagValues.push_back(value); return *this; }
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * subnet groups that are associated with the specified tag value or values. For
+     * example, suppose that you have subnet groups that are tagged with values called
+     * <code>admin</code> and <code>test</code>. If you specify both of these tag
+     * values in the request, Amazon Redshift returns a response with the subnet groups
+     * that have either or both of these tag values associated with them.</p>
+     */
+    inline DescribeClusterSubnetGroupsRequest& AddTagValues(Aws::String&& value) { m_tagValuesHasBeenSet = true; m_tagValues.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>A tag value or values for which you want to return all matching cluster
+     * subnet groups that are associated with the specified tag value or values. For
+     * example, suppose that you have subnet groups that are tagged with values called
+     * <code>admin</code> and <code>test</code>. If you specify both of these tag
+     * values in the request, Amazon Redshift returns a response with the subnet groups
+     * that have either or both of these tag values associated with them.</p>
+     */
+    inline DescribeClusterSubnetGroupsRequest& AddTagValues(const char* value) { m_tagValuesHasBeenSet = true; m_tagValues.push_back(value); return *this; }
+
+  private:
+
+    Aws::String m_clusterSubnetGroupName;
+    bool m_clusterSubnetGroupNameHasBeenSet;
+
+    int m_maxRecords;
+    bool m_maxRecordsHasBeenSet;
+
+    Aws::String m_marker;
+    bool m_markerHasBeenSet;
+
+    Aws::Vector<Aws::String> m_tagKeys;
+    bool m_tagKeysHasBeenSet;
+
+    Aws::Vector<Aws::String> m_tagValues;
+    bool m_tagValuesHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DescribeClusterSubnetGroupsResult.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/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <aws/redshift/model/ClusterSubnetGroup.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  /**
+   * <p>Contains the output from the <a>DescribeClusterSubnetGroups</a> action.
+   * </p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/ClusterSubnetGroupMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API DescribeClusterSubnetGroupsResult
+  {
+  public:
+    DescribeClusterSubnetGroupsResult();
+    DescribeClusterSubnetGroupsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    DescribeClusterSubnetGroupsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline const Aws::String& GetMarker() const{ return m_marker; }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline void SetMarker(const Aws::String& value) { m_marker = value; }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline void SetMarker(Aws::String&& value) { m_marker = std::move(value); }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline void SetMarker(const char* value) { m_marker.assign(value); }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline DescribeClusterSubnetGroupsResult& WithMarker(const Aws::String& value) { SetMarker(value); return *this;}
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline DescribeClusterSubnetGroupsResult& WithMarker(Aws::String&& value) { SetMarker(std::move(value)); return *this;}
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline DescribeClusterSubnetGroupsResult& WithMarker(const char* value) { SetMarker(value); return *this;}
+
+
+    /**
+     * <p>A list of <a>ClusterSubnetGroup</a> instances. </p>
+     */
+    inline const Aws::Vector<ClusterSubnetGroup>& GetClusterSubnetGroups() const{ return m_clusterSubnetGroups; }
+
+    /**
+     * <p>A list of <a>ClusterSubnetGroup</a> instances. </p>
+     */
+    inline void SetClusterSubnetGroups(const Aws::Vector<ClusterSubnetGroup>& value) { m_clusterSubnetGroups = value; }
+
+    /**
+     * <p>A list of <a>ClusterSubnetGroup</a> instances. </p>
+     */
+    inline void SetClusterSubnetGroups(Aws::Vector<ClusterSubnetGroup>&& value) { m_clusterSubnetGroups = std::move(value); }
+
+    /**
+     * <p>A list of <a>ClusterSubnetGroup</a> instances. </p>
+     */
+    inline DescribeClusterSubnetGroupsResult& WithClusterSubnetGroups(const Aws::Vector<ClusterSubnetGroup>& value) { SetClusterSubnetGroups(value); return *this;}
+
+    /**
+     * <p>A list of <a>ClusterSubnetGroup</a> instances. </p>
+     */
+    inline DescribeClusterSubnetGroupsResult& WithClusterSubnetGroups(Aws::Vector<ClusterSubnetGroup>&& value) { SetClusterSubnetGroups(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of <a>ClusterSubnetGroup</a> instances. </p>
+     */
+    inline DescribeClusterSubnetGroupsResult& AddClusterSubnetGroups(const ClusterSubnetGroup& value) { m_clusterSubnetGroups.push_back(value); return *this; }
+
+    /**
+     * <p>A list of <a>ClusterSubnetGroup</a> instances. </p>
+     */
+    inline DescribeClusterSubnetGroupsResult& AddClusterSubnetGroups(ClusterSubnetGroup&& value) { m_clusterSubnetGroups.push_back(std::move(value)); return *this; }
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline DescribeClusterSubnetGroupsResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline DescribeClusterSubnetGroupsResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_marker;
+
+    Aws::Vector<ClusterSubnetGroup> m_clusterSubnetGroups;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DescribeClusterTracksRequest.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/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_REDSHIFT_API DescribeClusterTracksRequest : public RedshiftRequest
+  {
+  public:
+    DescribeClusterTracksRequest();
+
+    // 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 "DescribeClusterTracks"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The name of the maintenance track. </p>
+     */
+    inline const Aws::String& GetMaintenanceTrackName() const{ return m_maintenanceTrackName; }
+
+    /**
+     * <p>The name of the maintenance track. </p>
+     */
+    inline bool MaintenanceTrackNameHasBeenSet() const { return m_maintenanceTrackNameHasBeenSet; }
+
+    /**
+     * <p>The name of the maintenance track. </p>
+     */
+    inline void SetMaintenanceTrackName(const Aws::String& value) { m_maintenanceTrackNameHasBeenSet = true; m_maintenanceTrackName = value; }
+
+    /**
+     * <p>The name of the maintenance track. </p>
+     */
+    inline void SetMaintenanceTrackName(Aws::String&& value) { m_maintenanceTrackNameHasBeenSet = true; m_maintenanceTrackName = std::move(value); }
+
+    /**
+     * <p>The name of the maintenance track. </p>
+     */
+    inline void SetMaintenanceTrackName(const char* value) { m_maintenanceTrackNameHasBeenSet = true; m_maintenanceTrackName.assign(value); }
+
+    /**
+     * <p>The name of the maintenance track. </p>
+     */
+    inline DescribeClusterTracksRequest& WithMaintenanceTrackName(const Aws::String& value) { SetMaintenanceTrackName(value); return *this;}
+
+    /**
+     * <p>The name of the maintenance track. </p>
+     */
+    inline DescribeClusterTracksRequest& WithMaintenanceTrackName(Aws::String&& value) { SetMaintenanceTrackName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the maintenance track. </p>
+     */
+    inline DescribeClusterTracksRequest& WithMaintenanceTrackName(const char* value) { SetMaintenanceTrackName(value); return *this;}
+
+
+    /**
+     * <p>An integer value for the maximum number of maintenance tracks to return.</p>
+     */
+    inline int GetMaxRecords() const{ return m_maxRecords; }
+
+    /**
+     * <p>An integer value for the maximum number of maintenance tracks to return.</p>
+     */
+    inline bool MaxRecordsHasBeenSet() const { return m_maxRecordsHasBeenSet; }
+
+    /**
+     * <p>An integer value for the maximum number of maintenance tracks to return.</p>
+     */
+    inline void SetMaxRecords(int value) { m_maxRecordsHasBeenSet = true; m_maxRecords = value; }
+
+    /**
+     * <p>An integer value for the maximum number of maintenance tracks to return.</p>
+     */
+    inline DescribeClusterTracksRequest& WithMaxRecords(int value) { SetMaxRecords(value); return *this;}
+
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <code>DescribeClusterTracks</code>
+     * request exceed the value specified in <code>MaxRecords</code>, Amazon Redshift
+     * returns a value in the <code>Marker</code> field of the response. You can
+     * retrieve the next set of response records by providing the returned marker value
+     * in the <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline const Aws::String& GetMarker() const{ return m_marker; }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <code>DescribeClusterTracks</code>
+     * request exceed the value specified in <code>MaxRecords</code>, Amazon Redshift
+     * returns a value in the <code>Marker</code> field of the response. You can
+     * retrieve the next set of response records by providing the returned marker value
+     * in the <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline bool MarkerHasBeenSet() const { return m_markerHasBeenSet; }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <code>DescribeClusterTracks</code>
+     * request exceed the value specified in <code>MaxRecords</code>, Amazon Redshift
+     * returns a value in the <code>Marker</code> field of the response. You can
+     * retrieve the next set of response records by providing the returned marker value
+     * in the <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline void SetMarker(const Aws::String& value) { m_markerHasBeenSet = true; m_marker = value; }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <code>DescribeClusterTracks</code>
+     * request exceed the value specified in <code>MaxRecords</code>, Amazon Redshift
+     * returns a value in the <code>Marker</code> field of the response. You can
+     * retrieve the next set of response records by providing the returned marker value
+     * in the <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline void SetMarker(Aws::String&& value) { m_markerHasBeenSet = true; m_marker = std::move(value); }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <code>DescribeClusterTracks</code>
+     * request exceed the value specified in <code>MaxRecords</code>, Amazon Redshift
+     * returns a value in the <code>Marker</code> field of the response. You can
+     * retrieve the next set of response records by providing the returned marker value
+     * in the <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline void SetMarker(const char* value) { m_markerHasBeenSet = true; m_marker.assign(value); }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <code>DescribeClusterTracks</code>
+     * request exceed the value specified in <code>MaxRecords</code>, Amazon Redshift
+     * returns a value in the <code>Marker</code> field of the response. You can
+     * retrieve the next set of response records by providing the returned marker value
+     * in the <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline DescribeClusterTracksRequest& WithMarker(const Aws::String& value) { SetMarker(value); return *this;}
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <code>DescribeClusterTracks</code>
+     * request exceed the value specified in <code>MaxRecords</code>, Amazon Redshift
+     * returns a value in the <code>Marker</code> field of the response. You can
+     * retrieve the next set of response records by providing the returned marker value
+     * in the <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline DescribeClusterTracksRequest& WithMarker(Aws::String&& value) { SetMarker(std::move(value)); return *this;}
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <code>DescribeClusterTracks</code>
+     * request exceed the value specified in <code>MaxRecords</code>, Amazon Redshift
+     * returns a value in the <code>Marker</code> field of the response. You can
+     * retrieve the next set of response records by providing the returned marker value
+     * in the <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline DescribeClusterTracksRequest& WithMarker(const char* value) { SetMarker(value); return *this;}
+
+  private:
+
+    Aws::String m_maintenanceTrackName;
+    bool m_maintenanceTrackNameHasBeenSet;
+
+    int m_maxRecords;
+    bool m_maxRecordsHasBeenSet;
+
+    Aws::String m_marker;
+    bool m_markerHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DescribeClusterTracksResult.h

@@ -0,0 +1,157 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <aws/redshift/model/MaintenanceTrack.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  class AWS_REDSHIFT_API DescribeClusterTracksResult
+  {
+  public:
+    DescribeClusterTracksResult();
+    DescribeClusterTracksResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    DescribeClusterTracksResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    /**
+     * <p>A list of maintenance tracks output by the <code>DescribeClusterTracks</code>
+     * operation. </p>
+     */
+    inline const Aws::Vector<MaintenanceTrack>& GetMaintenanceTracks() const{ return m_maintenanceTracks; }
+
+    /**
+     * <p>A list of maintenance tracks output by the <code>DescribeClusterTracks</code>
+     * operation. </p>
+     */
+    inline void SetMaintenanceTracks(const Aws::Vector<MaintenanceTrack>& value) { m_maintenanceTracks = value; }
+
+    /**
+     * <p>A list of maintenance tracks output by the <code>DescribeClusterTracks</code>
+     * operation. </p>
+     */
+    inline void SetMaintenanceTracks(Aws::Vector<MaintenanceTrack>&& value) { m_maintenanceTracks = std::move(value); }
+
+    /**
+     * <p>A list of maintenance tracks output by the <code>DescribeClusterTracks</code>
+     * operation. </p>
+     */
+    inline DescribeClusterTracksResult& WithMaintenanceTracks(const Aws::Vector<MaintenanceTrack>& value) { SetMaintenanceTracks(value); return *this;}
+
+    /**
+     * <p>A list of maintenance tracks output by the <code>DescribeClusterTracks</code>
+     * operation. </p>
+     */
+    inline DescribeClusterTracksResult& WithMaintenanceTracks(Aws::Vector<MaintenanceTrack>&& value) { SetMaintenanceTracks(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of maintenance tracks output by the <code>DescribeClusterTracks</code>
+     * operation. </p>
+     */
+    inline DescribeClusterTracksResult& AddMaintenanceTracks(const MaintenanceTrack& value) { m_maintenanceTracks.push_back(value); return *this; }
+
+    /**
+     * <p>A list of maintenance tracks output by the <code>DescribeClusterTracks</code>
+     * operation. </p>
+     */
+    inline DescribeClusterTracksResult& AddMaintenanceTracks(MaintenanceTrack&& value) { m_maintenanceTracks.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>The starting point to return a set of response tracklist records. You can
+     * retrieve the next set of response records by providing the returned marker value
+     * in the <code>Marker</code> parameter and retrying the request.</p>
+     */
+    inline const Aws::String& GetMarker() const{ return m_marker; }
+
+    /**
+     * <p>The starting point to return a set of response tracklist records. You can
+     * retrieve the next set of response records by providing the returned marker value
+     * in the <code>Marker</code> parameter and retrying the request.</p>
+     */
+    inline void SetMarker(const Aws::String& value) { m_marker = value; }
+
+    /**
+     * <p>The starting point to return a set of response tracklist records. You can
+     * retrieve the next set of response records by providing the returned marker value
+     * in the <code>Marker</code> parameter and retrying the request.</p>
+     */
+    inline void SetMarker(Aws::String&& value) { m_marker = std::move(value); }
+
+    /**
+     * <p>The starting point to return a set of response tracklist records. You can
+     * retrieve the next set of response records by providing the returned marker value
+     * in the <code>Marker</code> parameter and retrying the request.</p>
+     */
+    inline void SetMarker(const char* value) { m_marker.assign(value); }
+
+    /**
+     * <p>The starting point to return a set of response tracklist records. You can
+     * retrieve the next set of response records by providing the returned marker value
+     * in the <code>Marker</code> parameter and retrying the request.</p>
+     */
+    inline DescribeClusterTracksResult& WithMarker(const Aws::String& value) { SetMarker(value); return *this;}
+
+    /**
+     * <p>The starting point to return a set of response tracklist records. You can
+     * retrieve the next set of response records by providing the returned marker value
+     * in the <code>Marker</code> parameter and retrying the request.</p>
+     */
+    inline DescribeClusterTracksResult& WithMarker(Aws::String&& value) { SetMarker(std::move(value)); return *this;}
+
+    /**
+     * <p>The starting point to return a set of response tracklist records. You can
+     * retrieve the next set of response records by providing the returned marker value
+     * in the <code>Marker</code> parameter and retrying the request.</p>
+     */
+    inline DescribeClusterTracksResult& WithMarker(const char* value) { SetMarker(value); return *this;}
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline DescribeClusterTracksResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline DescribeClusterTracksResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    Aws::Vector<MaintenanceTrack> m_maintenanceTracks;
+
+    Aws::String m_marker;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DescribeClusterVersionsRequest.h

@@ -0,0 +1,286 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/redshift/Redshift_EXPORTS.h>
+#include <aws/redshift/RedshiftRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Redshift
+{
+namespace Model
+{
+
+  /**
+   * <p/><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/DescribeClusterVersionsMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API DescribeClusterVersionsRequest : public RedshiftRequest
+  {
+  public:
+    DescribeClusterVersionsRequest();
+
+    // 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 "DescribeClusterVersions"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The specific cluster version to return.</p> <p>Example: <code>1.0</code> </p>
+     */
+    inline const Aws::String& GetClusterVersion() const{ return m_clusterVersion; }
+
+    /**
+     * <p>The specific cluster version to return.</p> <p>Example: <code>1.0</code> </p>
+     */
+    inline bool ClusterVersionHasBeenSet() const { return m_clusterVersionHasBeenSet; }
+
+    /**
+     * <p>The specific cluster version to return.</p> <p>Example: <code>1.0</code> </p>
+     */
+    inline void SetClusterVersion(const Aws::String& value) { m_clusterVersionHasBeenSet = true; m_clusterVersion = value; }
+
+    /**
+     * <p>The specific cluster version to return.</p> <p>Example: <code>1.0</code> </p>
+     */
+    inline void SetClusterVersion(Aws::String&& value) { m_clusterVersionHasBeenSet = true; m_clusterVersion = std::move(value); }
+
+    /**
+     * <p>The specific cluster version to return.</p> <p>Example: <code>1.0</code> </p>
+     */
+    inline void SetClusterVersion(const char* value) { m_clusterVersionHasBeenSet = true; m_clusterVersion.assign(value); }
+
+    /**
+     * <p>The specific cluster version to return.</p> <p>Example: <code>1.0</code> </p>
+     */
+    inline DescribeClusterVersionsRequest& WithClusterVersion(const Aws::String& value) { SetClusterVersion(value); return *this;}
+
+    /**
+     * <p>The specific cluster version to return.</p> <p>Example: <code>1.0</code> </p>
+     */
+    inline DescribeClusterVersionsRequest& WithClusterVersion(Aws::String&& value) { SetClusterVersion(std::move(value)); return *this;}
+
+    /**
+     * <p>The specific cluster version to return.</p> <p>Example: <code>1.0</code> </p>
+     */
+    inline DescribeClusterVersionsRequest& WithClusterVersion(const char* value) { SetClusterVersion(value); return *this;}
+
+
+    /**
+     * <p>The name of a specific cluster parameter group family to return details
+     * for.</p> <p>Constraints:</p> <ul> <li> <p>Must be 1 to 255 alphanumeric
+     * characters</p> </li> <li> <p>First character must be a letter</p> </li> <li>
+     * <p>Cannot end with a hyphen or contain two consecutive hyphens</p> </li> </ul>
+     */
+    inline const Aws::String& GetClusterParameterGroupFamily() const{ return m_clusterParameterGroupFamily; }
+
+    /**
+     * <p>The name of a specific cluster parameter group family to return details
+     * for.</p> <p>Constraints:</p> <ul> <li> <p>Must be 1 to 255 alphanumeric
+     * characters</p> </li> <li> <p>First character must be a letter</p> </li> <li>
+     * <p>Cannot end with a hyphen or contain two consecutive hyphens</p> </li> </ul>
+     */
+    inline bool ClusterParameterGroupFamilyHasBeenSet() const { return m_clusterParameterGroupFamilyHasBeenSet; }
+
+    /**
+     * <p>The name of a specific cluster parameter group family to return details
+     * for.</p> <p>Constraints:</p> <ul> <li> <p>Must be 1 to 255 alphanumeric
+     * characters</p> </li> <li> <p>First character must be a letter</p> </li> <li>
+     * <p>Cannot end with a hyphen or contain two consecutive hyphens</p> </li> </ul>
+     */
+    inline void SetClusterParameterGroupFamily(const Aws::String& value) { m_clusterParameterGroupFamilyHasBeenSet = true; m_clusterParameterGroupFamily = value; }
+
+    /**
+     * <p>The name of a specific cluster parameter group family to return details
+     * for.</p> <p>Constraints:</p> <ul> <li> <p>Must be 1 to 255 alphanumeric
+     * characters</p> </li> <li> <p>First character must be a letter</p> </li> <li>
+     * <p>Cannot end with a hyphen or contain two consecutive hyphens</p> </li> </ul>
+     */
+    inline void SetClusterParameterGroupFamily(Aws::String&& value) { m_clusterParameterGroupFamilyHasBeenSet = true; m_clusterParameterGroupFamily = std::move(value); }
+
+    /**
+     * <p>The name of a specific cluster parameter group family to return details
+     * for.</p> <p>Constraints:</p> <ul> <li> <p>Must be 1 to 255 alphanumeric
+     * characters</p> </li> <li> <p>First character must be a letter</p> </li> <li>
+     * <p>Cannot end with a hyphen or contain two consecutive hyphens</p> </li> </ul>
+     */
+    inline void SetClusterParameterGroupFamily(const char* value) { m_clusterParameterGroupFamilyHasBeenSet = true; m_clusterParameterGroupFamily.assign(value); }
+
+    /**
+     * <p>The name of a specific cluster parameter group family to return details
+     * for.</p> <p>Constraints:</p> <ul> <li> <p>Must be 1 to 255 alphanumeric
+     * characters</p> </li> <li> <p>First character must be a letter</p> </li> <li>
+     * <p>Cannot end with a hyphen or contain two consecutive hyphens</p> </li> </ul>
+     */
+    inline DescribeClusterVersionsRequest& WithClusterParameterGroupFamily(const Aws::String& value) { SetClusterParameterGroupFamily(value); return *this;}
+
+    /**
+     * <p>The name of a specific cluster parameter group family to return details
+     * for.</p> <p>Constraints:</p> <ul> <li> <p>Must be 1 to 255 alphanumeric
+     * characters</p> </li> <li> <p>First character must be a letter</p> </li> <li>
+     * <p>Cannot end with a hyphen or contain two consecutive hyphens</p> </li> </ul>
+     */
+    inline DescribeClusterVersionsRequest& WithClusterParameterGroupFamily(Aws::String&& value) { SetClusterParameterGroupFamily(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of a specific cluster parameter group family to return details
+     * for.</p> <p>Constraints:</p> <ul> <li> <p>Must be 1 to 255 alphanumeric
+     * characters</p> </li> <li> <p>First character must be a letter</p> </li> <li>
+     * <p>Cannot end with a hyphen or contain two consecutive hyphens</p> </li> </ul>
+     */
+    inline DescribeClusterVersionsRequest& WithClusterParameterGroupFamily(const char* value) { SetClusterParameterGroupFamily(value); return *this;}
+
+
+    /**
+     * <p>The maximum number of response records to return in each call. If the number
+     * of remaining response records exceeds the specified <code>MaxRecords</code>
+     * value, a value is returned in a <code>marker</code> field of the response. You
+     * can retrieve the next set of records by retrying the command with the returned
+     * marker value. </p> <p>Default: <code>100</code> </p> <p>Constraints: minimum 20,
+     * maximum 100.</p>
+     */
+    inline int GetMaxRecords() const{ return m_maxRecords; }
+
+    /**
+     * <p>The maximum number of response records to return in each call. If the number
+     * of remaining response records exceeds the specified <code>MaxRecords</code>
+     * value, a value is returned in a <code>marker</code> field of the response. You
+     * can retrieve the next set of records by retrying the command with the returned
+     * marker value. </p> <p>Default: <code>100</code> </p> <p>Constraints: minimum 20,
+     * maximum 100.</p>
+     */
+    inline bool MaxRecordsHasBeenSet() const { return m_maxRecordsHasBeenSet; }
+
+    /**
+     * <p>The maximum number of response records to return in each call. If the number
+     * of remaining response records exceeds the specified <code>MaxRecords</code>
+     * value, a value is returned in a <code>marker</code> field of the response. You
+     * can retrieve the next set of records by retrying the command with the returned
+     * marker value. </p> <p>Default: <code>100</code> </p> <p>Constraints: minimum 20,
+     * maximum 100.</p>
+     */
+    inline void SetMaxRecords(int value) { m_maxRecordsHasBeenSet = true; m_maxRecords = value; }
+
+    /**
+     * <p>The maximum number of response records to return in each call. If the number
+     * of remaining response records exceeds the specified <code>MaxRecords</code>
+     * value, a value is returned in a <code>marker</code> field of the response. You
+     * can retrieve the next set of records by retrying the command with the returned
+     * marker value. </p> <p>Default: <code>100</code> </p> <p>Constraints: minimum 20,
+     * maximum 100.</p>
+     */
+    inline DescribeClusterVersionsRequest& WithMaxRecords(int value) { SetMaxRecords(value); return *this;}
+
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterVersions</a> request
+     * exceed the value specified in <code>MaxRecords</code>, AWS returns a value in
+     * the <code>Marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline const Aws::String& GetMarker() const{ return m_marker; }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterVersions</a> request
+     * exceed the value specified in <code>MaxRecords</code>, AWS returns a value in
+     * the <code>Marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline bool MarkerHasBeenSet() const { return m_markerHasBeenSet; }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterVersions</a> request
+     * exceed the value specified in <code>MaxRecords</code>, AWS returns a value in
+     * the <code>Marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline void SetMarker(const Aws::String& value) { m_markerHasBeenSet = true; m_marker = value; }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterVersions</a> request
+     * exceed the value specified in <code>MaxRecords</code>, AWS returns a value in
+     * the <code>Marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline void SetMarker(Aws::String&& value) { m_markerHasBeenSet = true; m_marker = std::move(value); }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterVersions</a> request
+     * exceed the value specified in <code>MaxRecords</code>, AWS returns a value in
+     * the <code>Marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline void SetMarker(const char* value) { m_markerHasBeenSet = true; m_marker.assign(value); }
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterVersions</a> request
+     * exceed the value specified in <code>MaxRecords</code>, AWS returns a value in
+     * the <code>Marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline DescribeClusterVersionsRequest& WithMarker(const Aws::String& value) { SetMarker(value); return *this;}
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterVersions</a> request
+     * exceed the value specified in <code>MaxRecords</code>, AWS returns a value in
+     * the <code>Marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline DescribeClusterVersionsRequest& WithMarker(Aws::String&& value) { SetMarker(std::move(value)); return *this;}
+
+    /**
+     * <p>An optional parameter that specifies the starting point to return a set of
+     * response records. When the results of a <a>DescribeClusterVersions</a> request
+     * exceed the value specified in <code>MaxRecords</code>, AWS returns a value in
+     * the <code>Marker</code> field of the response. You can retrieve the next set of
+     * response records by providing the returned marker value in the
+     * <code>Marker</code> parameter and retrying the request. </p>
+     */
+    inline DescribeClusterVersionsRequest& WithMarker(const char* value) { SetMarker(value); return *this;}
+
+  private:
+
+    Aws::String m_clusterVersion;
+    bool m_clusterVersionHasBeenSet;
+
+    Aws::String m_clusterParameterGroupFamily;
+    bool m_clusterParameterGroupFamilyHasBeenSet;
+
+    int m_maxRecords;
+    bool m_maxRecordsHasBeenSet;
+
+    Aws::String m_marker;
+    bool m_markerHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-redshift/include/aws/redshift/model/DescribeClusterVersionsResult.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/redshift/Redshift_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/redshift/model/ResponseMetadata.h>
+#include <aws/redshift/model/ClusterVersion.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace Redshift
+{
+namespace Model
+{
+  /**
+   * <p>Contains the output from the <a>DescribeClusterVersions</a> action.
+   * </p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/redshift-2012-12-01/ClusterVersionsMessage">AWS
+   * API Reference</a></p>
+   */
+  class AWS_REDSHIFT_API DescribeClusterVersionsResult
+  {
+  public:
+    DescribeClusterVersionsResult();
+    DescribeClusterVersionsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    DescribeClusterVersionsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline const Aws::String& GetMarker() const{ return m_marker; }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline void SetMarker(const Aws::String& value) { m_marker = value; }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline void SetMarker(Aws::String&& value) { m_marker = std::move(value); }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline void SetMarker(const char* value) { m_marker.assign(value); }
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline DescribeClusterVersionsResult& WithMarker(const Aws::String& value) { SetMarker(value); return *this;}
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline DescribeClusterVersionsResult& WithMarker(Aws::String&& value) { SetMarker(std::move(value)); return *this;}
+
+    /**
+     * <p>A value that indicates the starting point for the next set of response
+     * records in a subsequent request. If a value is returned in a response, you can
+     * retrieve the next set of records by providing this returned marker value in the
+     * <code>Marker</code> parameter and retrying the command. If the
+     * <code>Marker</code> field is empty, all response records have been retrieved for
+     * the request. </p>
+     */
+    inline DescribeClusterVersionsResult& WithMarker(const char* value) { SetMarker(value); return *this;}
+
+
+    /**
+     * <p>A list of <code>Version</code> elements. </p>
+     */
+    inline const Aws::Vector<ClusterVersion>& GetClusterVersions() const{ return m_clusterVersions; }
+
+    /**
+     * <p>A list of <code>Version</code> elements. </p>
+     */
+    inline void SetClusterVersions(const Aws::Vector<ClusterVersion>& value) { m_clusterVersions = value; }
+
+    /**
+     * <p>A list of <code>Version</code> elements. </p>
+     */
+    inline void SetClusterVersions(Aws::Vector<ClusterVersion>&& value) { m_clusterVersions = std::move(value); }
+
+    /**
+     * <p>A list of <code>Version</code> elements. </p>
+     */
+    inline DescribeClusterVersionsResult& WithClusterVersions(const Aws::Vector<ClusterVersion>& value) { SetClusterVersions(value); return *this;}
+
+    /**
+     * <p>A list of <code>Version</code> elements. </p>
+     */
+    inline DescribeClusterVersionsResult& WithClusterVersions(Aws::Vector<ClusterVersion>&& value) { SetClusterVersions(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of <code>Version</code> elements. </p>
+     */
+    inline DescribeClusterVersionsResult& AddClusterVersions(const ClusterVersion& value) { m_clusterVersions.push_back(value); return *this; }
+
+    /**
+     * <p>A list of <code>Version</code> elements. </p>
+     */
+    inline DescribeClusterVersionsResult& AddClusterVersions(ClusterVersion&& value) { m_clusterVersions.push_back(std::move(value)); return *this; }
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline DescribeClusterVersionsResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline DescribeClusterVersionsResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_marker;
+
+    Aws::Vector<ClusterVersion> m_clusterVersions;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace Redshift
+} // namespace Aws