text:
#pragma once
#include <aws/securityhub/SecurityHub_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/securityhub/model/AwsRedshiftClusterClusterSnapshotCopyStatus.h>
#include <aws/securityhub/model/AwsRedshiftClusterElasticIpStatus.h>
#include <aws/securityhub/model/AwsRedshiftClusterEndpoint.h>
#include <aws/securityhub/model/AwsRedshiftClusterHsmStatus.h>
#include <aws/securityhub/model/AwsRedshiftClusterPendingModifiedValues.h>
#include <aws/securityhub/model/AwsRedshiftClusterResizeInfo.h>
#include <aws/securityhub/model/AwsRedshiftClusterRestoreStatus.h>
#include <aws/securityhub/model/AwsRedshiftClusterClusterNode.h>
#include <aws/securityhub/model/AwsRedshiftClusterClusterParameterGroup.h>
#include <aws/securityhub/model/AwsRedshiftClusterClusterSecurityGroup.h>
#include <aws/securityhub/model/AwsRedshiftClusterDeferredMaintenanceWindow.h>
#include <aws/securityhub/model/AwsRedshiftClusterIamRole.h>
#include <aws/securityhub/model/AwsRedshiftClusterVpcSecurityGroup.h>
#include <utility>

namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace SecurityHub
{
namespace Model
{

  /**
   *
Details about an Amazon Redshift cluster.

See Also:
   AWS
   * API Reference

   */
  class AWS_SECURITYHUB_API AwsRedshiftClusterDetails
  {
  public:
    AwsRedshiftClusterDetails();
    AwsRedshiftClusterDetails(Aws::Utils::Json::JsonView jsonValue);
    AwsRedshiftClusterDetails& operator=(Aws::Utils::Json::JsonView jsonValue);
    Aws::Utils::Json::JsonValue Jsonize() const;

    /**
     *
Indicates whether major version upgrades are applied automatically to the
     * cluster during the maintenance window.

     */
    inline bool GetAllowVersionUpgrade() const{ return m_allowVersionUpgrade; }

    /**
     *
Indicates whether major version upgrades are applied automatically to the
     * cluster during the maintenance window.

     */
    inline bool AllowVersionUpgradeHasBeenSet() const { return m_allowVersionUpgradeHasBeenSet; }

    /**
     *
Indicates whether major version upgrades are applied automatically to the
     * cluster during the maintenance window.

     */
    inline void SetAllowVersionUpgrade(bool value) { m_allowVersionUpgradeHasBeenSet = true; m_allowVersionUpgrade = value; }

    /**
     *
Indicates whether major version upgrades are applied automatically to the
     * cluster during the maintenance window.

     */
    inline AwsRedshiftClusterDetails& WithAllowVersionUpgrade(bool value) { SetAllowVersionUpgrade(value); return *this;}

    /**
     *
The number of days that automatic cluster snapshots are retained.

     */
    inline int GetAutomatedSnapshotRetentionPeriod() const{ return m_automatedSnapshotRetentionPeriod; }

    /**
     *
The number of days that automatic cluster snapshots are retained.

     */
    inline bool AutomatedSnapshotRetentionPeriodHasBeenSet() const { return m_automatedSnapshotRetentionPeriodHasBeenSet; }

    /**
     *
The number of days that automatic cluster snapshots are retained.

     */
    inline void SetAutomatedSnapshotRetentionPeriod(int value) { m_automatedSnapshotRetentionPeriodHasBeenSet = true; m_automatedSnapshotRetentionPeriod = value; }

    /**
     *
The number of days that automatic cluster snapshots are retained.

     */
    inline AwsRedshiftClusterDetails& WithAutomatedSnapshotRetentionPeriod(int value) { SetAutomatedSnapshotRetentionPeriod(value); return *this;}

    /**
     *
The name of the Availability Zone in which the cluster is located.

     */
    inline const Aws::String& GetAvailabilityZone() const{ return m_availabilityZone; }

    /**
     *
The name of the Availability Zone in which the cluster is located.

     */
    inline bool AvailabilityZoneHasBeenSet() const { return m_availabilityZoneHasBeenSet; }

    /**
     *
The name of the Availability Zone in which the cluster is located.

     */
    inline void SetAvailabilityZone(const Aws::String& value) { m_availabilityZoneHasBeenSet = true; m_availabilityZone = value; }

    /**
     *
The name of the Availability Zone in which the cluster is located.

     */
    inline void SetAvailabilityZone(Aws::String&& value) { m_availabilityZoneHasBeenSet = true; m_availabilityZone = std::move(value); }

    /**
     *
The name of the Availability Zone in which the cluster is located.

     */
    inline void SetAvailabilityZone(const char* value) { m_availabilityZoneHasBeenSet = true; m_availabilityZone.assign(value); }

    /**
     *
The name of the Availability Zone in which the cluster is located.

     */
    inline AwsRedshiftClusterDetails& WithAvailabilityZone(const Aws::String& value) { SetAvailabilityZone(value); return *this;}

    /**
     *
The name of the Availability Zone in which the cluster is located.

     */
    inline AwsRedshiftClusterDetails& WithAvailabilityZone(Aws::String&& value) { SetAvailabilityZone(std::move(value)); return *this;}

    /**
     *
The name of the Availability Zone in which the cluster is located.

     */
    inline AwsRedshiftClusterDetails& WithAvailabilityZone(const char* value) { SetAvailabilityZone(value); return *this;}

    /**
     *
The availability status of the cluster for queries. Possible values are the
     * following:

 Available - The cluster is available
     * for queries.

 Unavailable - The cluster is not
     * available for queries.

 Maintenance - The cluster
     * is intermittently available for queries due to maintenance activities.

     *

 Modifying -The cluster is intermittently available for
     * queries due to changes that modify the cluster.

     * Failed - The cluster failed and is not available for queries.

     *

     */
    inline const Aws::String& GetClusterAvailabilityStatus() const{ return m_clusterAvailabilityStatus; }

    /**
     *
The availability status of the cluster for queries. Possible values are the
     * following:

 Available - The cluster is available
     * for queries.

 Unavailable - The cluster is not
     * available for queries.

 Maintenance - The cluster
     * is intermittently available for queries due to maintenance activities.

     *

 Modifying -The cluster is intermittently available for
     * queries due to changes that modify the cluster.

     * Failed - The cluster failed and is not available for queries.

     *

     */
    inline bool ClusterAvailabilityStatusHasBeenSet() const { return m_clusterAvailabilityStatusHasBeenSet; }

    /**
     *
The availability status of the cluster for queries. Possible values are the
     * following:

 Available - The cluster is available
     * for queries.

 Unavailable - The cluster is not
     * available for queries.

 Maintenance - The cluster
     * is intermittently available for queries due to maintenance activities.

     *

 Modifying -The cluster is intermittently available for
     * queries due to changes that modify the cluster.

     * Failed - The cluster failed and is not available for queries.

     *

     */
    inline void SetClusterAvailabilityStatus(const Aws::String& value) { m_clusterAvailabilityStatusHasBeenSet = true; m_clusterAvailabilityStatus = value; }

    /**
     *
The availability status of the cluster for queries. Possible values are the
     * following:

 Available - The cluster is available
     * for queries.

 Unavailable - The cluster is not
     * available for queries.

 Maintenance - The cluster
     * is intermittently available for queries due to maintenance activities.

     *

 Modifying -The cluster is intermittently available for
     * queries due to changes that modify the cluster.

     * Failed - The cluster failed and is not available for queries.

     *

     */
    inline void SetClusterAvailabilityStatus(Aws::String&& value) { m_clusterAvailabilityStatusHasBeenSet = true; m_clusterAvailabilityStatus = std::move(value); }

    /**
     *
The availability status of the cluster for queries. Possible values are the
     * following:

 Available - The cluster is available
     * for queries.

 Unavailable - The cluster is not
     * available for queries.

 Maintenance - The cluster
     * is intermittently available for queries due to maintenance activities.

     *

 Modifying -The cluster is intermittently available for
     * queries due to changes that modify the cluster.

     * Failed - The cluster failed and is not available for queries.

     *

     */
    inline void SetClusterAvailabilityStatus(const char* value) { m_clusterAvailabilityStatusHasBeenSet = true; m_clusterAvailabilityStatus.assign(value); }

    /**
     *
The availability status of the cluster for queries. Possible values are the
     * following:

 Available - The cluster is available
     * for queries.

 Unavailable - The cluster is not
     * available for queries.

 Maintenance - The cluster
     * is intermittently available for queries due to maintenance activities.

     *

 Modifying -The cluster is intermittently available for
     * queries due to changes that modify the cluster.

     * Failed - The cluster failed and is not available for queries.

     *

     */
    inline AwsRedshiftClusterDetails& WithClusterAvailabilityStatus(const Aws::String& value) { SetClusterAvailabilityStatus(value); return *this;}

    /**
     *
The availability status of the cluster for queries. Possible values are the
     * following:

 Available - The cluster is available
     * for queries.

 Unavailable - The cluster is not
     * available for queries.

 Maintenance - The cluster
     * is intermittently available for queries due to maintenance activities.

     *

 Modifying -The cluster is intermittently available for
     * queries due to changes that modify the cluster.

     * Failed - The cluster failed and is not available for queries.

     *

     */
    inline AwsRedshiftClusterDetails& WithClusterAvailabilityStatus(Aws::String&& value) { SetClusterAvailabilityStatus(std::move(value)); return *this;}

    /**
     *
The availability status of the cluster for queries. Possible values are the
     * following:

 Available - The cluster is available
     * for queries.

 Unavailable - The cluster is not
     * available for queries.

 Maintenance - The cluster
     * is intermittently available for queries due to maintenance activities.

     *

 Modifying -The cluster is intermittently available for
     * queries due to changes that modify the cluster.

     * Failed - The cluster failed and is not available for queries.

     *

     */
    inline AwsRedshiftClusterDetails& WithClusterAvailabilityStatus(const char* value) { SetClusterAvailabilityStatus(value); return *this;}

    /**
     *
Indicates when the cluster was created.

Uses the
     * date-time format specified in RFC 3339 section 5.6,
     * Internet Date/Time Format. The value cannot contain spaces. For example,
     * 2020-03-22T13:22:13.933Z.

     */
    inline const Aws::String& GetClusterCreateTime() const{ return m_clusterCreateTime; }

    /**
     *
Indicates when the cluster was created.

Uses the
     * date-time format specified in RFC 3339 section 5.6,
     * Internet Date/Time Format. The value cannot contain spaces. For example,
     * 2020-03-22T13:22:13.933Z.

     */
    inline bool ClusterCreateTimeHasBeenSet() const { return m_clusterCreateTimeHasBeenSet; }

    /**
     *
Indicates when the cluster was created.

Uses the
     * date-time format specified in RFC 3339 section 5.6,
     * Internet Date/Time Format. The value cannot contain spaces. For example,
     * 2020-03-22T13:22:13.933Z.

     */
    inline void SetClusterCreateTime(const Aws::String& value) { m_clusterCreateTimeHasBeenSet = true; m_clusterCreateTime = value; }

    /**
     *
Indicates when the cluster was created.

Uses the
     * date-time format specified in RFC 3339 section 5.6,
     * Internet Date/Time Format. The value cannot contain spaces. For example,
     * 2020-03-22T13:22:13.933Z.

     */
    inline void SetClusterCreateTime(Aws::String&& value) { m_clusterCreateTimeHasBeenSet = true; m_clusterCreateTime = std::move(value); }

    /**
     *
Indicates when the cluster was created.

Uses the
     * date-time format specified in RFC 3339 section 5.6,
     * Internet Date/Time Format. The value cannot contain spaces. For example,
     * 2020-03-22T13:22:13.933Z.

     */
    inline void SetClusterCreateTime(const char* value) { m_clusterCreateTimeHasBeenSet = true; m_clusterCreateTime.assign(value); }

    /**
     *
Indicates when the cluster was created.

Uses the
     * date-time format specified in RFC 3339 section 5.6,
     * Internet Date/Time Format. The value cannot contain spaces. For example,
     * 2020-03-22T13:22:13.933Z.

     */
    inline AwsRedshiftClusterDetails& WithClusterCreateTime(const Aws::String& value) { SetClusterCreateTime(value); return *this;}

    /**
     *
Indicates when the cluster was created.

Uses the
     * date-time format specified in RFC 3339 section 5.6,
     * Internet Date/Time Format. The value cannot contain spaces. For example,
     * 2020-03-22T13:22:13.933Z.

     */
    inline AwsRedshiftClusterDetails& WithClusterCreateTime(Aws::String&& value) { SetClusterCreateTime(std::move(value)); return *this;}

    /**
     *
Indicates when the cluster was created.

Uses the
     * date-time format specified in RFC 3339 section 5.6,
     * Internet Date/Time Format. The value cannot contain spaces. For example,
     * 2020-03-22T13:22:13.933Z.

     */
    inline AwsRedshiftClusterDetails& WithClusterCreateTime(const char* value) { SetClusterCreateTime(value); return *this;}

    /**
     *
The unique identifier of the cluster.

     */
    inline const Aws::String& GetClusterIdentifier() const{ return m_clusterIdentifier; }

    /**
     *
The unique identifier of the cluster.

     */
    inline bool ClusterIdentifierHasBeenSet() const { return m_clusterIdentifierHasBeenSet; }

    /**
     *
The unique identifier of the cluster.

     */
    inline void SetClusterIdentifier(const Aws::String& value) { m_clusterIdentifierHasBeenSet = true; m_clusterIdentifier = value; }

    /**
     *
The unique identifier of the cluster.

     */
    inline void SetClusterIdentifier(Aws::String&& value) { m_clusterIdentifierHasBeenSet = true; m_clusterIdentifier = std::move(value); }

    /**
     *
The unique identifier of the cluster.

     */
    inline void SetClusterIdentifier(const char* value) { m_clusterIdentifierHasBeenSet = true; m_clusterIdentifier.assign(value); }

    /**
     *
The unique identifier of the cluster.

     */
    inline AwsRedshiftClusterDetails& WithClusterIdentifier(const Aws::String& value) { SetClusterIdentifier(value); return *this;}

    /**
     *
The unique identifier of the cluster.

     */
    inline AwsRedshiftClusterDetails& WithClusterIdentifier(Aws::String&& value) { SetClusterIdentifier(std::move(value)); return *this;}

    /**
     *
The unique identifier of the cluster.

     */
    inline AwsRedshiftClusterDetails& WithClusterIdentifier(const char* value) { SetClusterIdentifier(value); return *this;}

    /**
     *
The nodes in the cluster.

     */
    inline const Aws::Vector<AwsRedshiftClusterClusterNode>& GetClusterNodes() const{ return m_clusterNodes; }

    /**
     *
The nodes in the cluster.

     */
    inline bool ClusterNodesHasBeenSet() const { return m_clusterNodesHasBeenSet; }

    /**
     *
The nodes in the cluster.

     */
    inline void SetClusterNodes(const Aws::Vector<AwsRedshiftClusterClusterNode>& value) { m_clusterNodesHasBeenSet = true; m_clusterNodes = value; }

    /**
     *
The nodes in the cluster.

     */
    inline void SetClusterNodes(Aws::Vector<AwsRedshiftClusterClusterNode>&& value) { m_clusterNodesHasBeenSet = true; m_clusterNodes = std::move(value); }

    /**
     *
The nodes in the cluster.

     */
    inline AwsRedshiftClusterDetails& WithClusterNodes(const Aws::Vector<AwsRedshiftClusterClusterNode>& value) { SetClusterNodes(value); return *this;}

    /**
     *
The nodes in the cluster.

     */
    inline AwsRedshiftClusterDetails& WithClusterNodes(Aws::Vector<AwsRedshiftClusterClusterNode>&& value) { SetClusterNodes(std::move(value)); return *this;}

    /**
     *
The nodes in the cluster.

     */
    inline AwsRedshiftClusterDetails& AddClusterNodes(const AwsRedshiftClusterClusterNode& value) { m_clusterNodesHasBeenSet = true; m_clusterNodes.push_back(value); return *this; }

    /**
     *
The nodes in the cluster.

     */
    inline AwsRedshiftClusterDetails& AddClusterNodes(AwsRedshiftClusterClusterNode&& value) { m_clusterNodesHasBeenSet = true; m_clusterNodes.push_back(std::move(value)); return *this; }

    /**
     *
The list of cluster parameter groups that are associated with this
     * cluster.

     */
    inline const Aws::Vector<AwsRedshiftClusterClusterParameterGroup>& GetClusterParameterGroups() const{ return m_clusterParameterGroups; }

    /**
     *
The list of cluster parameter groups that are associated with this
     * cluster.

     */
    inline bool ClusterParameterGroupsHasBeenSet() const { return m_clusterParameterGroupsHasBeenSet; }

    /**
     *
The list of cluster parameter groups that are associated with this
     * cluster.

     */
    inline void SetClusterParameterGroups(const Aws::Vector<AwsRedshiftClusterClusterParameterGroup>& value) { m_clusterParameterGroupsHasBeenSet = true; m_clusterParameterGroups = value; }

    /**
     *
The list of cluster parameter groups that are associated with this
     * cluster.

     */
    inline void SetClusterParameterGroups(Aws::Vector<AwsRedshiftClusterClusterParameterGroup>&& value) { m_clusterParameterGroupsHasBeenSet = true; m_clusterParameterGroups = std::move(value); }

    /**
     *
The list of cluster parameter groups that are associated with this
     * cluster.

     */
    inline AwsRedshiftClusterDetails& WithClusterParameterGroups(const Aws::Vector<AwsRedshiftClusterClusterParameterGroup>& value) { SetClusterParameterGroups(value); return *this;}

    /**
     *
The list of cluster parameter groups that are associated with this
     * cluster.

     */
    inline AwsRedshiftClusterDetails& WithClusterParameterGroups(Aws::Vector<AwsRedshiftClusterClusterParameterGroup>&& value) { SetClusterParameterGroups(std::move(value)); return *this;}

    /**
     *
The list of cluster parameter groups that are associated with this
     * cluster.

     */
    inline AwsRedshiftClusterDetails& AddClusterParameterGroups(const AwsRedshiftClusterClusterParameterGroup& value) { m_clusterParameterGroupsHasBeenSet = true; m_clusterParameterGroups.push_back(value); return *this; }

    /**
     *
The list of cluster parameter groups that are associated with this
     * cluster.

     */
    inline AwsRedshiftClusterDetails& AddClusterParameterGroups(AwsRedshiftClusterClusterParameterGroup&& value) { m_clusterParameterGroupsHasBeenSet = true; m_clusterParameterGroups.push_back(std::move(value)); return *this; }

    /**
     *
The public key for the cluster.

     */
    inline const Aws::String& GetClusterPublicKey() const{ return m_clusterPublicKey; }

    /**
     *
The public key for the cluster.

     */
    inline bool ClusterPublicKeyHasBeenSet() const { return m_clusterPublicKeyHasBeenSet; }

    /**
     *
The public key for the cluster.

     */
    inline void SetClusterPublicKey(const Aws::String& value) { m_clusterPublicKeyHasBeenSet = true; m_clusterPublicKey = value; }

    /**
     *
The public key for the cluster.

     */
    inline void SetClusterPublicKey(Aws::String&& value) { m_clusterPublicKeyHasBeenSet = true; m_clusterPublicKey = std::move(value); }

    /**
     *
The public key for the cluster.

     */
    inline void SetClusterPublicKey(const char* value) { m_clusterPublicKeyHasBeenSet = true; m_clusterPublicKey.assign(value); }

    /**
     *
The public key for the cluster.

     */
    inline AwsRedshiftClusterDetails& WithClusterPublicKey(const Aws::String& value) { SetClusterPublicKey(value); return *this;}

    /**
     *
The public key for the cluster.

     */
    inline AwsRedshiftClusterDetails& WithClusterPublicKey(Aws::String&& value) { SetClusterPublicKey(std::move(value)); return *this;}

    /**
     *
The public key for the cluster.

     */
    inline AwsRedshiftClusterDetails& WithClusterPublicKey(const char* value) { SetClusterPublicKey(value); return *this;}

    /**
     *
The specific revision number of the database in the cluster.

     */
    inline const Aws::String& GetClusterRevisionNumber() const{ return m_clusterRevisionNumber; }

    /**
     *
The specific revision number of the database in the cluster.

     */
    inline bool ClusterRevisionNumberHasBeenSet() const { return m_clusterRevisionNumberHasBeenSet; }

    /**
     *
The specific revision number of the database in the cluster.

     */
    inline void SetClusterRevisionNumber(const Aws::String& value) { m_clusterRevisionNumberHasBeenSet = true; m_clusterRevisionNumber = value; }

    /**
     *
The specific revision number of the database in the cluster.

     */
    inline void SetClusterRevisionNumber(Aws::String&& value) { m_clusterRevisionNumberHasBeenSet = true; m_clusterRevisionNumber = std::move(value); }

    /**
     *
The specific revision number of the database in the cluster.

     */
    inline void SetClusterRevisionNumber(const char* value) { m_clusterRevisionNumberHasBeenSet = true; m_clusterRevisionNumber.assign(value); }

    /**
     *
The specific revision number of the database in the cluster.

     */
    inline AwsRedshiftClusterDetails& WithClusterRevisionNumber(const Aws::String& value) { SetClusterRevisionNumber(value); return *this;}

    /**
     *
The specific revision number of the database in the cluster.

     */
    inline AwsRedshiftClusterDetails& WithClusterRevisionNumber(Aws::String&& value) { SetClusterRevisionNumber(std::move(value)); return *this;}

    /**
     *
The specific revision number of the database in the cluster.

     */
    inline AwsRedshiftClusterDetails& WithClusterRevisionNumber(const char* value) { SetClusterRevisionNumber(value); return *this;}

    /**
     *
A list of cluster security groups that are associated with the cluster.

     */
    inline const Aws::Vector<AwsRedshiftClusterClusterSecurityGroup>& GetClusterSecurityGroups() const{ return m_clusterSecurityGroups; }

    /**
     *
A list of cluster security groups that are associated with the cluster.

     */
    inline bool ClusterSecurityGroupsHasBeenSet() const { return m_clusterSecurityGroupsHasBeenSet; }

    /**
     *
A list of cluster security groups that are associated with the cluster.

     */
    inline void SetClusterSecurityGroups(const Aws::Vector<AwsRedshiftClusterClusterSecurityGroup>& value) { m_clusterSecurityGroupsHasBeenSet = true; m_clusterSecurityGroups = value; }

    /**
     *
A list of cluster security groups that are associated with the cluster.

     */
    inline void SetClusterSecurityGroups(Aws::Vector<AwsRedshiftClusterClusterSecurityGroup>&& value) { m_clusterSecurityGroupsHasBeenSet = true; m_clusterSecurityGroups = std::move(value); }

    /**
     *
A list of cluster security groups that are associated with the cluster.

     */
    inline AwsRedshiftClusterDetails& WithClusterSecurityGroups(const Aws::Vector<AwsRedshiftClusterClusterSecurityGroup>& value) { SetClusterSecurityGroups(value); return *this;}

    /**
     *
A list of cluster security groups that are associated with the cluster.

     */
    inline AwsRedshiftClusterDetails& WithClusterSecurityGroups(Aws::Vector<AwsRedshiftClusterClusterSecurityGroup>&& value) { SetClusterSecurityGroups(std::move(value)); return *this;}

    /**
     *
A list of cluster security groups that are associated with the cluster.

     */
    inline AwsRedshiftClusterDetails& AddClusterSecurityGroups(const AwsRedshiftClusterClusterSecurityGroup& value) { m_clusterSecurityGroupsHasBeenSet = true; m_clusterSecurityGroups.push_back(value); return *this; }

    /**
     *
A list of cluster security groups that are associated with the cluster.

     */
    inline AwsRedshiftClusterDetails& AddClusterSecurityGroups(AwsRedshiftClusterClusterSecurityGroup&& value) { m_clusterSecurityGroupsHasBeenSet = true; m_clusterSecurityGroups.push_back(std::move(value)); return *this; }

    /**
     *
Information about the destination Region and retention period for the
     * cross-Region snapshot copy.

     */
    inline const AwsRedshiftClusterClusterSnapshotCopyStatus& GetClusterSnapshotCopyStatus() const{ return m_clusterSnapshotCopyStatus; }

    /**
     *
Information about the destination Region and retention period for the
     * cross-Region snapshot copy.

     */
    inline bool ClusterSnapshotCopyStatusHasBeenSet() const { return m_clusterSnapshotCopyStatusHasBeenSet; }

    /**
     *
Information about the destination Region and retention period for the
     * cross-Region snapshot copy.

     */
    inline void SetClusterSnapshotCopyStatus(const AwsRedshiftClusterClusterSnapshotCopyStatus& value) { m_clusterSnapshotCopyStatusHasBeenSet = true; m_clusterSnapshotCopyStatus = value; }

    /**
     *
Information about the destination Region and retention period for the
     * cross-Region snapshot copy.

     */
    inline void SetClusterSnapshotCopyStatus(AwsRedshiftClusterClusterSnapshotCopyStatus&& value) { m_clusterSnapshotCopyStatusHasBeenSet = true; m_clusterSnapshotCopyStatus = std::move(value); }

    /**
     *
Information about the destination Region and retention period for the
     * cross-Region snapshot copy.

     */
    inline AwsRedshiftClusterDetails& WithClusterSnapshotCopyStatus(const AwsRedshiftClusterClusterSnapshotCopyStatus& value) { SetClusterSnapshotCopyStatus(value); return *this;}

    /**
     *
Information about the destination Region and retention period for the
     * cross-Region snapshot copy.

     */
    inline AwsRedshiftClusterDetails& WithClusterSnapshotCopyStatus(AwsRedshiftClusterClusterSnapshotCopyStatus&& value) { SetClusterSnapshotCopyStatus(std::move(value)); return *this;}

    /**
     *
The current status of the cluster.

Valid values:
     * available | available, prep-for-resize |
     * available, resize-cleanup | cancelling-resize |
     * creating | deleting | final-snapshot |
     * hardware-failure | incompatible-hsm |
     * incompatible-network | incompatible-parameters |
     * incompatible-restore | modifying | paused
     * | rebooting | renaming | resizing |
     * rotating-keys | storage-full |
     * updating-hsm

     */
    inline const Aws::String& GetClusterStatus() const{ return m_clusterStatus; }

    /**
     *
The current status of the cluster.

Valid values:
     * available | available, prep-for-resize |
     * available, resize-cleanup | cancelling-resize |
     * creating | deleting | final-snapshot |
     * hardware-failure | incompatible-hsm |
     * incompatible-network | incompatible-parameters |
     * incompatible-restore | modifying | paused
     * | rebooting | renaming | resizing |
     * rotating-keys | storage-full |
     * updating-hsm

     */
    inline bool ClusterStatusHasBeenSet() const { return m_clusterStatusHasBeenSet; }

    /**
     *
The current status of the cluster.

Valid values:
     * available | available, prep-for-resize |
     * available, resize-cleanup | cancelling-resize |
     * creating | deleting | final-snapshot |
     * hardware-failure | incompatible-hsm |
     * incompatible-network | incompatible-parameters |
     * incompatible-restore | modifying | paused
     * | rebooting | renaming | resizing |
     * rotating-keys | storage-full |
     * updating-hsm

     */
    inline void SetClusterStatus(const Aws::String& value) { m_clusterStatusHasBeenSet = true; m_clusterStatus = value; }

    /**
     *
The current status of the cluster.

Valid values:
     * available | available, prep-for-resize |
     * available, resize-cleanup | cancelling-resize |
     * creating | deleting | final-snapshot |
     * hardware-failure | incompatible-hsm |
     * incompatible-network | incompatible-parameters |
     * incompatible-restore | modifying | paused
     * | rebooting | renaming | resizing |
     * rotating-keys | storage-full |
     * updating-hsm

     */
    inline void SetClusterStatus(Aws::String&& value) { m_clusterStatusHasBeenSet = true; m_clusterStatus = std::move(value); }

    /**
     *
The current status of the cluster.

Valid values:
     * available | available, prep-for-resize |
     * available, resize-cleanup | cancelling-resize |
     * creating | deleting | final-snapshot |
     * hardware-failure | incompatible-hsm |
     * incompatible-network | incompatible-parameters |
     * incompatible-restore | modifying | paused
     * | rebooting | renaming | resizing |
     * rotating-keys | storage-full |
     * updating-hsm

     */
    inline void SetClusterStatus(const char* value) { m_clusterStatusHasBeenSet = true; m_clusterStatus.assign(value); }

    /**
     *
The current status of the cluster.

Valid values:
     * available | available, prep-for-resize |
     * available, resize-cleanup | cancelling-resize |
     * creating | deleting | final-snapshot |
     * hardware-failure | incompatible-hsm |
     * incompatible-network | incompatible-parameters |
     * incompatible-restore | modifying | paused
     * | rebooting | renaming | resizing |
     * rotating-keys | storage-full |
     * updating-hsm

     */
    inline AwsRedshiftClusterDetails& WithClusterStatus(const Aws::String& value) { SetClusterStatus(value); return *this;}

    /**
     *
The current status of the cluster.

Valid values:
     * available | available, prep-for-resize |
     * available, resize-cleanup | cancelling-resize |
     * creating | deleting | final-snapshot |
     * hardware-failure | incompatible-hsm |
     * incompatible-network | incompatible-parameters |
     * incompatible-restore | modifying | paused
     * | rebooting | renaming | resizing |
     * rotating-keys | storage-full |
     * updating-hsm

     */
    inline AwsRedshiftClusterDetails& WithClusterStatus(Aws::String&& value) { SetClusterStatus(std::move(value)); return *this;}

    /**
     *
The current status of the cluster.

Valid values:
     * available | available, prep-for-resize |
     * available, resize-cleanup | cancelling-resize |
     * creating | deleting | final-snapshot |
     * hardware-failure | incompatible-hsm |
     * incompatible-network | incompatible-parameters |
     * incompatible-restore | modifying | paused
     * | rebooting | renaming | resizing |
     * rotating-keys | storage-full |
     * updating-hsm

     */
    inline AwsRedshiftClusterDetails& WithClusterStatus(const char* value) { SetClusterStatus(value); return *this;}

    /**
     *
The name of the subnet group that is associated with the cluster. This
     * parameter is valid only when the cluster is in a VPC.

     */
    inline const Aws::String& GetClusterSubnetGroupName() const{ return m_clusterSubnetGroupName; }

    /**
     *
The name of the subnet group that is associated with the cluster. This
     * parameter is valid only when the cluster is in a VPC.

     */
    inline bool ClusterSubnetGroupNameHasBeenSet() const { return m_clusterSubnetGroupNameHasBeenSet; }

    /**
     *
The name of the subnet group that is associated with the cluster. This
     * parameter is valid only when the cluster is in a VPC.

     */
    inline void SetClusterSubnetGroupName(const Aws::String& value) { m_clusterSubnetGroupNameHasBeenSet = true; m_clusterSubnetGroupName = value; }

    /**
     *
The name of the subnet group that is associated with the cluster. This
     * parameter is valid only when the cluster is in a VPC.

     */
    inline void SetClusterSubnetGroupName(Aws::String&& value) { m_clusterSubnetGroupNameHasBeenSet = true; m_clusterSubnetGroupName = std::move(value); }

    /**
     *
The name of the subnet group that is associated with the cluster. This
     * parameter is valid only when the cluster is in a VPC.

     */
    inline void SetClusterSubnetGroupName(const char* value) { m_clusterSubnetGroupNameHasBeenSet = true; m_clusterSubnetGroupName.assign(value); }

    /**
     *
The name of the subnet group that is associated with the cluster. This
     * parameter is valid only when the cluster is in a VPC.

     */
    inline AwsRedshiftClusterDetails& WithClusterSubnetGroupName(const Aws::String& value) { SetClusterSubnetGroupName(value); return *this;}

    /**
     *
The name of the subnet group that is associated with the cluster. This
     * parameter is valid only when the cluster is in a VPC.

     */
    inline AwsRedshiftClusterDetails& WithClusterSubnetGroupName(Aws::String&& value) { SetClusterSubnetGroupName(std::move(value)); return *this;}

    /**
     *
The name of the subnet group that is associated with the cluster. This
     * parameter is valid only when the cluster is in a VPC.

     */
    inline AwsRedshiftClusterDetails& WithClusterSubnetGroupName(const char* value) { SetClusterSubnetGroupName(value); return *this;}

    /**
     *
The version ID of the Amazon Redshift engine that runs on the cluster.

     */
    inline const Aws::String& GetClusterVersion() const{ return m_clusterVersion; }

    /**
     *
The version ID of the Amazon Redshift engine that runs on the cluster.

     */
    inline bool ClusterVersionHasBeenSet() const { return m_clusterVersionHasBeenSet; }

    /**
     *
The version ID of the Amazon Redshift engine that runs on the cluster.

     */
    inline void SetClusterVersion(const Aws::String& value) { m_clusterVersionHasBeenSet = true; m_clusterVersion = value; }

    /**
     *
The version ID of the Amazon Redshift engine that runs on the cluster.

     */
    inline void SetClusterVersion(Aws::String&& value) { m_clusterVersionHasBeenSet = true; m_clusterVersion = std::move(value); }

    /**
     *
The version ID of the Amazon Redshift engine that runs on the cluster.

     */
    inline void SetClusterVersion(const char* value) { m_clusterVersionHasBeenSet = true; m_clusterVersion.assign(value); }

    /**
     *
The version ID of the Amazon Redshift engine that runs on the cluster.

     */
    inline AwsRedshiftClusterDetails& WithClusterVersion(const Aws::String& value) { SetClusterVersion(value); return *this;}

    /**
     *
The version ID of the Amazon Redshift engine that runs on the cluster.

     */
    inline AwsRedshiftClusterDetails& WithClusterVersion(Aws::String&& value) { SetClusterVersion(std::move(value)); return *this;}

    /**
     *
The version ID of the Amazon Redshift engine that runs on the cluster.

     */
    inline AwsRedshiftClusterDetails& WithClusterVersion(const char* value) { SetClusterVersion(value); return *this;}

    /**
     *
The name of the initial database that was created when the cluster was
     * created.

The same name is returned for the life of the cluster.

If
     * an initial database is not specified, a database named devdev is
     * created by default.

     */
    inline const Aws::String& GetDBName() const{ return m_dBName; }

    /**
     *
The name of the initial database that was created when the cluster was
     * created.

The same name is returned for the life of the cluster.

If
     * an initial database is not specified, a database named devdev is
     * created by default.

     */
    inline bool DBNameHasBeenSet() const { return m_dBNameHasBeenSet; }

    /**
     *
The name of the initial database that was created when the cluster was
     * created.

The same name is returned for the life of the cluster.

If
     * an initial database is not specified, a database named devdev is
     * created by default.

     */
    inline void SetDBName(const Aws::String& value) { m_dBNameHasBeenSet = true; m_dBName = value; }

    /**
     *
The name of the initial database that was created when the cluster was
     * created.

The same name is returned for the life of the cluster.

If
     * an initial database is not specified, a database named devdev is
     * created by default.

     */
    inline void SetDBName(Aws::String&& value) { m_dBNameHasBeenSet = true; m_dBName = std::move(value); }

    /**
     *
The name of the initial database that was created when the cluster was
     * created.

The same name is returned for the life of the cluster.

If
     * an initial database is not specified, a database named devdev is
     * created by default.

     */
    inline void SetDBName(const char* value) { m_dBNameHasBeenSet = true; m_dBName.assign(value); }

    /**
     *
The name of the initial database that was created when the cluster was
     * created.

The same name is returned for the life of the cluster.

If
     * an initial database is not specified, a database named devdev is
     * created by default.

     */
    inline AwsRedshiftClusterDetails& WithDBName(const Aws::String& value) { SetDBName(value); return *this;}

    /**
     *
The name of the initial database that was created when the cluster was
     * created.

The same name is returned for the life of the cluster.

If
     * an initial database is not specified, a database named devdev is
     * created by default.

     */
    inline AwsRedshiftClusterDetails& WithDBName(Aws::String&& value) { SetDBName(std::move(value)); return *this;}

    /**
     *
The name of the initial database that was created when the cluster was
     * created.

The same name is returned for the life of the cluster.

If
     * an initial database is not specified, a database named devdev is
     * created by default.

     */
    inline AwsRedshiftClusterDetails& WithDBName(const char* value) { SetDBName(value); return *this;}

    /**
     *
List of time windows during which maintenance was deferred.

     */
    inline const Aws::Vector<AwsRedshiftClusterDeferredMaintenanceWindow>& GetDeferredMaintenanceWindows() const{ return m_deferredMaintenanceWindows; }

    /**
     *
List of time windows during which maintenance was deferred.

     */
    inline bool DeferredMaintenanceWindowsHasBeenSet() const { return m_deferredMaintenanceWindowsHasBeenSet; }

    /**
     *
List of time windows during which maintenance was deferred.

     */
    inline void SetDeferredMaintenanceWindows(const Aws::Vector<AwsRedshiftClusterDeferredMaintenanceWindow>& value) { m_deferredMaintenanceWindowsHasBeenSet = true; m_deferredMaintenanceWindows = value; }

    /**
     *
List of time windows during which maintenance was deferred.

     */
    inline void SetDeferredMaintenanceWindows(Aws::Vector<AwsRedshiftClusterDeferredMaintenanceWindow>&& value) { m_deferredMaintenanceWindowsHasBeenSet = true; m_deferredMaintenanceWindows = std::move(value); }

    /**
     *
List of time windows during which maintenance was deferred.

     */
    inline AwsRedshiftClusterDetails& WithDeferredMaintenanceWindows(const Aws::Vector<AwsRedshiftClusterDeferredMaintenanceWindow>& value) { SetDeferredMaintenanceWindows(value); return *this;}

    /**
     *
List of time windows during which maintenance was deferred.

     */
    inline AwsRedshiftClusterDetails& WithDeferredMaintenanceWindows(Aws::Vector<AwsRedshiftClusterDeferredMaintenanceWindow>&& value) { SetDeferredMaintenanceWindows(std::move(value)); return *this;}

    /**
     *
List of time windows during which maintenance was deferred.

     */
    inline AwsRedshiftClusterDetails& AddDeferredMaintenanceWindows(const AwsRedshiftClusterDeferredMaintenanceWindow& value) { m_deferredMaintenanceWindowsHasBeenSet = true; m_deferredMaintenanceWindows.push_back(value); return *this; }

    /**
     *
List of time windows during which maintenance was deferred.

     */
    inline AwsRedshiftClusterDetails& AddDeferredMaintenanceWindows(AwsRedshiftClusterDeferredMaintenanceWindow&& value) { m_deferredMaintenanceWindowsHasBeenSet = true; m_deferredMaintenanceWindows.push_back(std::move(value)); return *this; }

    /**
     *
Information about the status of the Elastic IP (EIP) address.

     */
    inline const AwsRedshiftClusterElasticIpStatus& GetElasticIpStatus() const{ return m_elasticIpStatus; }

    /**
     *
Information about the status of the Elastic IP (EIP) address.

     */
    inline bool ElasticIpStatusHasBeenSet() const { return m_elasticIpStatusHasBeenSet; }

    /**
     *
Information about the status of the Elastic IP (EIP) address.

     */
    inline void SetElasticIpStatus(const AwsRedshiftClusterElasticIpStatus& value) { m_elasticIpStatusHasBeenSet = true; m_elasticIpStatus = value; }

    /**
     *
Information about the status of the Elastic IP (EIP) address.

     */
    inline void SetElasticIpStatus(AwsRedshiftClusterElasticIpStatus&& value) { m_elasticIpStatusHasBeenSet = true; m_elasticIpStatus = std::move(value); }

    /**
     *
Information about the status of the Elastic IP (EIP) address.

     */
    inline AwsRedshiftClusterDetails& WithElasticIpStatus(const AwsRedshiftClusterElasticIpStatus& value) { SetElasticIpStatus(value); return *this;}

    /**
     *
Information about the status of the Elastic IP (EIP) address.

     */
    inline AwsRedshiftClusterDetails& WithElasticIpStatus(AwsRedshiftClusterElasticIpStatus&& value) { SetElasticIpStatus(std::move(value)); return *this;}

    /**
     *
The number of nodes that you can use the elastic resize method to resize the
     * cluster to.

     */
    inline const Aws::String& GetElasticResizeNumberOfNodeOptions() const{ return m_elasticResizeNumberOfNodeOptions; }

    /**
     *
The number of nodes that you can use the elastic resize method to resize the
     * cluster to.

     */
    inline bool ElasticResizeNumberOfNodeOptionsHasBeenSet() const { return m_elasticResizeNumberOfNodeOptionsHasBeenSet; }

    /**
     *
The number of nodes that you can use the elastic resize method to resize the
     * cluster to.

     */
    inline void SetElasticResizeNumberOfNodeOptions(const Aws::String& value) { m_elasticResizeNumberOfNodeOptionsHasBeenSet = true; m_elasticResizeNumberOfNodeOptions = value; }

    /**
     *
The number of nodes that you can use the elastic resize method to resize the
     * cluster to.

     */
    inline void SetElasticResizeNumberOfNodeOptions(Aws::String&& value) { m_elasticResizeNumberOfNodeOptionsHasBeenSet = true; m_elasticResizeNumberOfNodeOptions = std::move(value); }

    /**
     *
The number of nodes that you can use the elastic resize method to resize the
     * cluster to.

     */
    inline void SetElasticResizeNumberOfNodeOptions(const char* value) { m_elasticResizeNumberOfNodeOptionsHasBeenSet = true; m_elasticResizeNumberOfNodeOptions.assign(value); }

    /**
     *
The number of nodes that you can use the elastic resize method to resize the
     * cluster to.

     */
    inline AwsRedshiftClusterDetails& WithElasticResizeNumberOfNodeOptions(const Aws::String& value) { SetElasticResizeNumberOfNodeOptions(value); return *this;}

    /**
     *
The number of nodes that you can use the elastic resize method to resize the
     * cluster to.

     */
    inline AwsRedshiftClusterDetails& WithElasticResizeNumberOfNodeOptions(Aws::String&& value) { SetElasticResizeNumberOfNodeOptions(std::move(value)); return *this;}

    /**
     *
The number of nodes that you can use the elastic resize method to resize the
     * cluster to.

     */
    inline AwsRedshiftClusterDetails& WithElasticResizeNumberOfNodeOptions(const char* value) { SetElasticResizeNumberOfNodeOptions(value); return *this;}

    /**
     *
Indicates whether the data in the cluster is encrypted at rest.

     */
    inline bool GetEncrypted() const{ return m_encrypted; }

    /**
     *
Indicates whether the data in the cluster is encrypted at rest.

     */
    inline bool EncryptedHasBeenSet() const { return m_encryptedHasBeenSet; }

    /**
     *
Indicates whether the data in the cluster is encrypted at rest.

     */
    inline void SetEncrypted(bool value) { m_encryptedHasBeenSet = true; m_encrypted = value; }

    /**
     *
Indicates whether the data in the cluster is encrypted at rest.

     */
    inline AwsRedshiftClusterDetails& WithEncrypted(bool value) { SetEncrypted(value); return *this;}

    /**
     *
The connection endpoint.

     */
    inline const AwsRedshiftClusterEndpoint& GetEndpoint() const{ return m_endpoint; }

    /**
     *
The connection endpoint.

     */
    inline bool EndpointHasBeenSet() const { return m_endpointHasBeenSet; }

    /**
     *
The connection endpoint.

     */
    inline void SetEndpoint(const AwsRedshiftClusterEndpoint& value) { m_endpointHasBeenSet = true; m_endpoint = value; }

    /**
     *
The connection endpoint.

     */
    inline void SetEndpoint(AwsRedshiftClusterEndpoint&& value) { m_endpointHasBeenSet = true; m_endpoint = std::move(value); }

    /**
     *
The connection endpoint.

     */
    inline AwsRedshiftClusterDetails& WithEndpoint(const AwsRedshiftClusterEndpoint& value) { SetEndpoint(value); return *this;}

    /**
     *
The connection endpoint.

     */
    inline AwsRedshiftClusterDetails& WithEndpoint(AwsRedshiftClusterEndpoint&& value) { SetEndpoint(std::move(value)); return *this;}

    /**
     *
Indicates whether to create the cluster with enhanced VPC routing
     * enabled.

     */
    inline bool GetEnhancedVpcRouting() const{ return m_enhancedVpcRouting; }

    /**
     *
Indicates whether to create the cluster with enhanced VPC routing
     * enabled.

     */
    inline bool EnhancedVpcRoutingHasBeenSet() const { return m_enhancedVpcRoutingHasBeenSet; }

    /**
     *
Indicates whether to create the cluster with enhanced VPC routing
     * enabled.

     */
    inline void SetEnhancedVpcRouting(bool value) { m_enhancedVpcRoutingHasBeenSet = true; m_enhancedVpcRouting = value; }

    /**
     *
Indicates whether to create the cluster with enhanced VPC routing
     * enabled.

     */
    inline AwsRedshiftClusterDetails& WithEnhancedVpcRouting(bool value) { SetEnhancedVpcRouting(value); return *this;}

    /**
     *
Indicates when the next snapshot is expected to be taken. The cluster must
     * have a valid snapshot schedule and have backups enabled.

Uses the
     * date-time format specified in RFC 3339 section 5.6,
     * Internet Date/Time Format. The value cannot contain spaces. For example,
     * 2020-03-22T13:22:13.933Z.

     */
    inline const Aws::String& GetExpectedNextSnapshotScheduleTime() const{ return m_expectedNextSnapshotScheduleTime; }

    /**
     *
Indicates when the next snapshot is expected to be taken. The cluster must
     * have a valid snapshot schedule and have backups enabled.

Uses the
     * date-time format specified in RFC 3339 section 5.6,
     * Internet Date/Time Format. The value cannot contain spaces. For example,
     * 2020-03-22T13:22:13.933Z.

     */
    inline bool ExpectedNextSnapshotScheduleTimeHasBeenSet() const { return m_expectedNextSnapshotScheduleTimeHasBeenSet; }

    /**
     *
Indicates when the next snapshot is expected to be taken. The cluster must
     * have a valid snapshot schedule and have backups enabled.

Uses the
     * date-time format specified in RFC 3339 section 5.6,
     * Internet Date/Time Format. The value cannot contain spaces. For example,
     * 2020-03-22T13:22:13.933Z.

     */
    inline void SetExpectedNextSnapshotScheduleTime(const Aws::String& value) { m_expectedNextSnapshotScheduleTimeHasBeenSet = true; m_expectedNextSnapshotScheduleTime = value; }

    /**
     *
Indicates when the next snapshot is expected to be taken. The cluster must
     * have a valid snapshot schedule and have backups enabled.

Uses the
     * date-time format specified in RFC 3339 section 5.6,
     * Internet Date/Time Format. The value cannot contain spaces. For example,
     * 2020-03-22T13:22:13.933Z.

     */
    inline void SetExpectedNextSnapshotScheduleTime(Aws::String&& value) { m_expectedNextSnapshotScheduleTimeHasBeenSet = true; m_expectedNextSnapshotScheduleTime = std::move(value); }

    /**
     *
Indicates when the next snapshot is expected to be taken. The cluster must
     * have a valid snapshot schedule and have backups enabled.

Uses the
     * date-time format specified in RFC 3339 section 5.6,
     * Internet Date/Time Format. The value cannot contain spaces. For example,
     * 2020-03-22T13:22:13.933Z.

     */
    inline void SetExpectedNextSnapshotScheduleTime(const char* value) { m_expectedNextSnapshotScheduleTimeHasBeenSet = true; m_expectedNextSnapshotScheduleTime.assign(value); }

    /**
     *
Indicates when the next snapshot is expected to be taken. The cluster must
     * have a valid snapshot schedule and have backups enabled.

Uses the
     * date-time format specified in RFC 3339 section 5.6,
     * Internet Date/Time Format. The value cannot contain spaces. For example,
     * 2020-03-22T13:22:13.933Z.

     */
    inline AwsRedshiftClusterDetails& WithExpectedNextSnapshotScheduleTime(const Aws::String& value) { SetExpectedNextSnapshotScheduleTime(value); return *this;}

    /**
     *
Indicates when the next snapshot is expected to be taken. The cluster must
     * have a valid snapshot schedule and have backups enabled.

Uses the
     * date-time format specified in RFC 3339 section 5.6,
     * Internet Date/Time Format. The value cannot contain spaces. For example,
     * 2020-03-22T13:22:13.933Z.

     */
    inline AwsRedshiftClusterDetails& WithExpectedNextSnapshotScheduleTime(Aws::String&& value) { SetExpectedNextSnapshotScheduleTime(std::move(value)); return *this;}

    /**
     *
Indicates when the next snapshot is expected to be taken. The cluster must
     * have a valid snapshot schedule and have backups enabled.

Uses the
     * date-time format specified in RFC 3339 section 5.6,
     * Internet Date/Time Format. The value cannot contain spaces. For example,
     * 2020-03-22T13:22:13.933Z.

     */
    inline AwsRedshiftClusterDetails& WithExpectedNextSnapshotScheduleTime(const char* value) { SetExpectedNextSnapshotScheduleTime(value); return *this;}

    /**
     *
The status of the next expected snapshot.

Valid values:
     * OnTrack | Pending

     */
    inline const Aws::String& GetExpectedNextSnapshotScheduleTimeStatus() const{ return m_expectedNextSnapshotScheduleTimeStatus; }

    /**
     *
The status of the next expected snapshot.

Valid values:
     * OnTrack | Pending

     */
    inline bool ExpectedNextSnapshotScheduleTimeStatusHasBeenSet() const { return m_expectedNextSnapshotScheduleTimeStatusHasBeenSet; }

    /**
     *
The status of the next expected snapshot.

Valid values:
     * OnTrack | Pending

     */
    inline void SetExpectedNextSnapshotScheduleTimeStatus(const Aws::String& value) { m_expectedNextSnapshotScheduleTimeStatusHasBeenSet = true; m_expectedNextSnapshotScheduleTimeStatus = value; }

    /**
     *
The status of the next expected snapshot.

Valid values:
     * OnTrack | Pending

     */
    inline void SetExpectedNextSnapshotScheduleTimeStatus(Aws::String&& value) { m_expectedNextSnapshotScheduleTimeStatusHasBeenSet = true; m_expectedNextSnapshotScheduleTimeStatus = std::move(value); }

    /**
     *
The status of the next expected snapshot.

Valid values:
     * OnTrack | Pending

     */
    inline void SetExpectedNextSnapshotScheduleTimeStatus(const char* value) { m_expectedNextSnapshotScheduleTimeStatusHasBeenSet = true; m_expectedNextSnapshotScheduleTimeStatus.assign(value); }

    /**
     *
The status of the next expected snapshot.

Valid values:
     * OnTrack | Pending

     */
    inline AwsRedshiftClusterDetails& WithExpectedNextSnapshotScheduleTimeStatus(const Aws::String& value) { SetExpectedNextSnapshotScheduleTimeStatus(value); return *this;}

    /**
     *
The status of the next expected snapshot.

Valid values:
     * OnTrack | Pending

     */
    inline AwsRedshiftClusterDetails& WithExpectedNextSnapshotScheduleTimeStatus(Aws::String&& value) { SetExpectedNextSnapshotScheduleTimeStatus(std::move(value)); return *this;}

    /**
     *
The status of the next expected snapshot.

Valid values:
     * OnTrack | Pending

     */
    inline AwsRedshiftClusterDetails& WithExpectedNextSnapshotScheduleTimeStatus(const char* value) { SetExpectedNextSnapshotScheduleTimeStatus(value); return *this;}

    /**
     *
Information about whether the Amazon Redshift cluster finished applying any
     * changes to hardware security module (HSM) settings that were specified in a
     * modify cluster command.

     */
    inline const AwsRedshiftClusterHsmStatus& GetHsmStatus() const{ return m_hsmStatus; }

    /**
     *
Information about whether the Amazon Redshift cluster finished applying any
     * changes to hardware security module (HSM) settings that were specified in a
     * modify cluster command.

     */
    inline bool HsmStatusHasBeenSet() const { return m_hsmStatusHasBeenSet; }

    /**
     *
Information about whether the Amazon Redshift cluster finished applying any
     * changes to hardware security module (HSM) settings that were specified in a
     * modify cluster command.

     */
    inline void SetHsmStatus(const AwsRedshiftClusterHsmStatus& value) { m_hsmStatusHasBeenSet = true; m_hsmStatus = value; }

    /**
     *
Information about whether the Amazon Redshift cluster finished applying any
     * changes to hardware security module (HSM) settings that were specified in a
     * modify cluster command.

     */
    inline void SetHsmStatus(AwsRedshiftClusterHsmStatus&& value) { m_hsmStatusHasBeenSet = true; m_hsmStatus = std::move(value); }

    /**
     *
Information about whether the Amazon Redshift cluster finished applying any
     * changes to hardware security module (HSM) settings that were specified in a
     * modify cluster command.

     */
    inline AwsRedshiftClusterDetails& WithHsmStatus(const AwsRedshiftClusterHsmStatus& value) { SetHsmStatus(value); return *this;}

    /**
     *
Information about whether the Amazon Redshift cluster finished applying any
     * changes to hardware security module (HSM) settings that were specified in a
     * modify cluster command.

     */
    inline AwsRedshiftClusterDetails& WithHsmStatus(AwsRedshiftClusterHsmStatus&& value) { SetHsmStatus(std::move(value)); return *this;}

    /**
     *
A list of IAM roles that the cluster can use to access other AWS
     * services.

     */
    inline const Aws::Vector<AwsRedshiftClusterIamRole>& GetIamRoles() const{ return m_iamRoles; }

    /**
     *
A list of IAM roles that the cluster can use to access other AWS
     * services.

     */
    inline bool IamRolesHasBeenSet() const { return m_iamRolesHasBeenSet; }

    /**
     *
A list of IAM roles that the cluster can use to access other AWS
     * services.

     */
    inline void SetIamRoles(const Aws::Vector<AwsRedshiftClusterIamRole>& value) { m_iamRolesHasBeenSet = true; m_iamRoles = value; }

    /**
     *
A list of IAM roles that the cluster can use to access other AWS
     * services.

     */
    inline void SetIamRoles(Aws::Vector<AwsRedshiftClusterIamRole>&& value) { m_iamRolesHasBeenSet = true; m_iamRoles = std::move(value); }

    /**
     *
A list of IAM roles that the cluster can use to access other AWS
     * services.

     */
    inline AwsRedshiftClusterDetails& WithIamRoles(const Aws::Vector<AwsRedshiftClusterIamRole>& value) { SetIamRoles(value); return *this;}

    /**
     *
A list of IAM roles that the cluster can use to access other AWS
     * services.

     */
    inline AwsRedshiftClusterDetails& WithIamRoles(Aws::Vector<AwsRedshiftClusterIamRole>&& value) { SetIamRoles(std::move(value)); return *this;}

    /**
     *
A list of IAM roles that the cluster can use to access other AWS
     * services.

     */
    inline AwsRedshiftClusterDetails& AddIamRoles(const AwsRedshiftClusterIamRole& value) { m_iamRolesHasBeenSet = true; m_iamRoles.push_back(value); return *this; }

    /**
     *
A list of IAM roles that the cluster can use to access other AWS
     * services.

     */
    inline AwsRedshiftClusterDetails& AddIamRoles(AwsRedshiftClusterIamRole&& value) { m_iamRolesHasBeenSet = true; m_iamRoles.push_back(std::move(value)); return *this; }

    /**
     *
The identifier of the AWS KMS encryption key that is used to encrypt data in
     * the cluster.

     */
    inline const Aws::String& GetKmsKeyId() const{ return m_kmsKeyId; }

    /**
     *
The identifier of the AWS KMS encryption key that is used to encrypt data in
     * the cluster.

     */
    inline bool KmsKeyIdHasBeenSet() const { return m_kmsKeyIdHasBeenSet; }

    /**
     *
The identifier of the AWS KMS encryption key that is used to encrypt data in
     * the cluster.

     */
    inline void SetKmsKeyId(const Aws::String& value) { m_kmsKeyIdHasBeenSet = true; m_kmsKeyId = value; }

    /**
     *
The identifier of the AWS KMS encryption key that is used to encrypt data in
     * the cluster.

     */
    inline void SetKmsKeyId(Aws::String&& value) { m_kmsKeyIdHasBeenSet = true; m_kmsKeyId = std::move(value); }

    /**
     *
The identifier of the AWS KMS encryption key that is used to encrypt data in
     * the cluster.

     */
    inline void SetKmsKeyId(const char* value) { m_kmsKeyIdHasBeenSet = true; m_kmsKeyId.assign(value); }

    /**
     *
The identifier of the AWS KMS encryption key that is used to encrypt data in
     * the cluster.

     */
    inline AwsRedshiftClusterDetails& WithKmsKeyId(const Aws::String& value) { SetKmsKeyId(value); return *this;}

    /**
     *
The identifier of the AWS KMS encryption key that is used to encrypt data in
     * the cluster.

     */
    inline AwsRedshiftClusterDetails& WithKmsKeyId(Aws::String&& value) { SetKmsKeyId(std::move(value)); return *this;}

    /**
     *
The identifier of the AWS KMS encryption key that is used to encrypt data in
     * the cluster.

     */
    inline AwsRedshiftClusterDetails& WithKmsKeyId(const char* value) { SetKmsKeyId(value); return *this;}

    /**
     *
The name of the maintenance track for the cluster.

     */
    inline const Aws::String& GetMaintenanceTrackName() const{ return m_maintenanceTrackName; }

    /**
     *
The name of the maintenance track for the cluster.

     */
    inline bool MaintenanceTrackNameHasBeenSet() const { return m_maintenanceTrackNameHasBeenSet; }

    /**
     *
The name of the maintenance track for the cluster.

     */
    inline void SetMaintenanceTrackName(const Aws::String& value) { m_maintenanceTrackNameHasBeenSet = true; m_maintenanceTrackName = value; }

    /**
     *
The name of the maintenance track for the cluster.

     */
    inline void SetMaintenanceTrackName(Aws::String&& value) { m_maintenanceTrackNameHasBeenSet = true; m_maintenanceTrackName = std::move(value); }

    /**
     *
The name of the maintenance track for the cluster.

     */
    inline void SetMaintenanceTrackName(const char* value) { m_maintenanceTrackNameHasBeenSet = true; m_maintenanceTrackName.assign(value); }

    /**
     *
The name of the maintenance track for the cluster.

     */
    inline AwsRedshiftClusterDetails& WithMaintenanceTrackName(const Aws::String& value) { SetMaintenanceTrackName(value); return *this;}

    /**
     *
The name of the maintenance track for the cluster.

     */
    inline AwsRedshiftClusterDetails& WithMaintenanceTrackName(Aws::String&& value) { SetMaintenanceTrackName(std::move(value)); return *this;}

    /**
     *
The name of the maintenance track for the cluster.

     */
    inline AwsRedshiftClusterDetails& WithMaintenanceTrackName(const char* value) { SetMaintenanceTrackName(value); return *this;}

    /**
     *
The default number of days to retain a manual snapshot.

If the value
     * is -1, the snapshot is retained indefinitely.

This setting doesn't change
     * the retention period of existing snapshots.

Valid values: Either -1 or an
     * integer between 1 and 3,653

     */
    inline int GetManualSnapshotRetentionPeriod() const{ return m_manualSnapshotRetentionPeriod; }

    /**
     *
The default number of days to retain a manual snapshot.

If the value
     * is -1, the snapshot is retained indefinitely.

This setting doesn't change
     * the retention period of existing snapshots.

Valid values: Either -1 or an
     * integer between 1 and 3,653

     */
    inline bool ManualSnapshotRetentionPeriodHasBeenSet() const { return m_manualSnapshotRetentionPeriodHasBeenSet; }

    /**
     *
The default number of days to retain a manual snapshot.

If the value
     * is -1, the snapshot is retained indefinitely.

This setting doesn't change
     * the retention period of existing snapshots.

Valid values: Either -1 or an
     * integer between 1 and 3,653

     */
    inline void SetManualSnapshotRetentionPeriod(int value) { m_manualSnapshotRetentionPeriodHasBeenSet = true; m_manualSnapshotRetentionPeriod = value; }

    /**
     *
The default number of days to retain a manual snapshot.

If the value
     * is -1, the snapshot is retained indefinitely.

This setting doesn't change
     * the retention period of existing snapshots.

Valid values: Either -1 or an
     * integer between 1 and 3,653

     */
    inline AwsRedshiftClusterDetails& WithManualSnapshotRetentionPeriod(int value) { SetManualSnapshotRetentionPeriod(value); return *this;}

    /**
     *
The master user name for the cluster. This name is used to connect to the
     * database that is specified in as the value of DBName.

     */
    inline const Aws::String& GetMasterUsername() const{ return m_masterUsername; }

    /**
     *
The master user name for the cluster. This name is used to connect to the
     * database that is specified in as the value of DBName.

     */
    inline bool MasterUsernameHasBeenSet() const { return m_masterUsernameHasBeenSet; }

    /**
     *
The master user name for the cluster. This name is used to connect to the
     * database that is specified in as the value of DBName.

     */
    inline void SetMasterUsername(const Aws::String& value) { m_masterUsernameHasBeenSet = true; m_masterUsername = value; }

    /**
     *
The master user name for the cluster. This name is used to connect to the
     * database that is specified in as the value of DBName.

     */
    inline void SetMasterUsername(Aws::String&& value) { m_masterUsernameHasBeenSet = true; m_masterUsername = std::move(value); }

    /**
     *
The master user name for the cluster. This name is used to connect to the
     * database that is specified in as the value of DBName.

     */
    inline void SetMasterUsername(const char* value) { m_masterUsernameHasBeenSet = true; m_masterUsername.assign(value); }

    /**
     *
The master user name for the cluster. This name is used to connect to the
     * database that is specified in as the value of DBName.

     */
    inline AwsRedshiftClusterDetails& WithMasterUsername(const Aws::String& value) { SetMasterUsername(value); return *this;}

    /**
     *
The master user name for the cluster. This name is used to connect to the
     * database that is specified in as the value of DBName.

     */
    inline AwsRedshiftClusterDetails& WithMasterUsername(Aws::String&& value) { SetMasterUsername(std::move(value)); return *this;}

    /**
     *
The master user name for the cluster. This name is used to connect to the
     * database that is specified in as the value of DBName.

     */
    inline AwsRedshiftClusterDetails& WithMasterUsername(const char* value) { SetMasterUsername(value); return *this;}

    /**
     *
Indicates the start of the next maintenance window.

Uses the
     * date-time format specified in RFC 3339 section 5.6,
     * Internet Date/Time Format. The value cannot contain spaces. For example,
     * 2020-03-22T13:22:13.933Z.

     */
    inline const Aws::String& GetNextMaintenanceWindowStartTime() const{ return m_nextMaintenanceWindowStartTime; }

    /**
     *
Indicates the start of the next maintenance window.

Uses the
     * date-time format specified in RFC 3339 section 5.6,
     * Internet Date/Time Format. The value cannot contain spaces. For example,
     * 2020-03-22T13:22:13.933Z.

     */
    inline bool NextMaintenanceWindowStartTimeHasBeenSet() const { return m_nextMaintenanceWindowStartTimeHasBeenSet; }

    /**
     *
Indicates the start of the next maintenance window.

Uses the
     * date-time format specified in RFC 3339 section 5.6,
     * Internet Date/Time Format. The value cannot contain spaces. For example,
     * 2020-03-22T13:22:13.933Z.

     */
    inline void SetNextMaintenanceWindowStartTime(const Aws::String& value) { m_nextMaintenanceWindowStartTimeHasBeenSet = true; m_nextMaintenanceWindowStartTime = value; }

    /**
     *
Indicates the start of the next maintenance window.

Uses the
     * date-time format specified in RFC 3339 section 5.6,
     * Internet Date/Time Format. The value cannot contain spaces. For example,
     * 2020-03-22T13:22:13.933Z.

     */
    inline void SetNextMaintenanceWindowStartTime(Aws::String&& value) { m_nextMaintenanceWindowStartTimeHasBeenSet = true; m_nextMaintenanceWindowStartTime = std::move(value); }

    /**
     *
Indicates the start of the next maintenance window.

Uses the
     * date-time format specified in RFC 3339 section 5.6,
     * Internet Date/Time Format. The value cannot contain spaces. For example,
     * 2020-03-22T13:22:13.933Z.

     */
    inline void SetNextMaintenanceWindowStartTime(const char* value) { m_nextMaintenanceWindowStartTimeHasBeenSet = true; m_nextMaintenanceWindowStartTime.assign(value); }

    /**
     *
Indicates the start of the next maintenance window.

Uses the
     * date-time format specified in RFC 3339 section 5.6,
     * Internet Date/Time Format. The value cannot contain spaces. For example,
     * 2020-03-22T13:22:13.933Z.

     */
    inline AwsRedshiftClusterDetails& WithNextMaintenanceWindowStartTime(const Aws::String& value) { SetNextMaintenanceWindowStartTime(value); return *this;}

    /**
     *
Indicates the start of the next maintenance window.

Uses the
     * date-time format specified in RFC 3339 section 5.6,
     * Internet Date/Time Format. The value cannot contain spaces. For example,
     * 2020-03-22T13:22:13.933Z.

     */
    inline AwsRedshiftClusterDetails& WithNextMaintenanceWindowStartTime(Aws::String&& value) { SetNextMaintenanceWindowStartTime(std::move(value)); return *this;}

    /**
     *
Indicates the start of the next maintenance window.

Uses the
     * date-time format specified in RFC 3339 section 5.6,
     * Internet Date/Time Format. The value cannot contain spaces. For example,
     * 2020-03-22T13:22:13.933Z.

     */
    inline AwsRedshiftClusterDetails& WithNextMaintenanceWindowStartTime(const char* value) { SetNextMaintenanceWindowStartTime(value); return *this;}

    /**
     *
The node type for the nodes in the cluster.

     */
    inline const Aws::String& GetNodeType() const{ return m_nodeType; }

    /**
     *
The node type for the nodes in the cluster.

     */
    inline bool NodeTypeHasBeenSet() const { return m_nodeTypeHasBeenSet; }

    /**
     *
The node type for the nodes in the cluster.

     */
    inline void SetNodeType(const Aws::String& value) { m_nodeTypeHasBeenSet = true; m_nodeType = value; }

    /**
     *
The node type for the nodes in the cluster.

     */
    inline void SetNodeType(Aws::String&& value) { m_nodeTypeHasBeenSet = true; m_nodeType = std::move(value); }

    /**
     *
The node type for the nodes in the cluster.

     */
    inline void SetNodeType(const char* value) { m_nodeTypeHasBeenSet = true; m_nodeType.assign(value); }

    /**
     *
The node type for the nodes in the cluster.

     */
    inline AwsRedshiftClusterDetails& WithNodeType(const Aws::String& value) { SetNodeType(value); return *this;}

    /**
     *
The node type for the nodes in the cluster.

     */
    inline AwsRedshiftClusterDetails& WithNodeType(Aws::String&& value) { SetNodeType(std::move(value)); return *this;}

    /**
     *
The node type for the nodes in the cluster.

     */
    inline AwsRedshiftClusterDetails& WithNodeType(const char* value) { SetNodeType(value); return *this;}

    /**
     *
The number of compute nodes in the cluster.

     */
    inline int GetNumberOfNodes() const{ return m_numberOfNodes; }

    /**
     *
The number of compute nodes in the cluster.

     */
    inline bool NumberOfNodesHasBeenSet() const { return m_numberOfNodesHasBeenSet; }

    /**
     *
The number of compute nodes in the cluster.

     */
    inline void SetNumberOfNodes(int value) { m_numberOfNodesHasBeenSet = true; m_numberOfNodes = value; }

    /**
     *
The number of compute nodes in the cluster.

     */
    inline AwsRedshiftClusterDetails& WithNumberOfNodes(int value) { SetNumberOfNodes(value); return *this;}

    /**
     *
A list of cluster operations that are waiting to start.

     */
    inline const Aws::Vector<Aws::String>& GetPendingActions() const{ return m_pendingActions; }

    /**
     *
A list of cluster operations that are waiting to start.

     */
    inline bool PendingActionsHasBeenSet() const { return m_pendingActionsHasBeenSet; }

    /**
     *
A list of cluster operations that are waiting to start.

     */
    inline void SetPendingActions(const Aws::Vector<Aws::String>& value) { m_pendingActionsHasBeenSet = true; m_pendingActions = value; }

    /**
     *
A list of cluster operations that are waiting to start.

     */
    inline void SetPendingActions(Aws::Vector<Aws::String>&& value) { m_pendingActionsHasBeenSet = true; m_pendingActions = std::move(value); }

    /**
     *
A list of cluster operations that are waiting to start.

     */
    inline AwsRedshiftClusterDetails& WithPendingActions(const Aws::Vector<Aws::String>& value) { SetPendingActions(value); return *this;}

    /**
     *
A list of cluster operations that are waiting to start.

     */
    inline AwsRedshiftClusterDetails& WithPendingActions(Aws::Vector<Aws::String>&& value) { SetPendingActions(std::move(value)); return *this;}

    /**
     *
A list of cluster operations that are waiting to start.

     */
    inline AwsRedshiftClusterDetails& AddPendingActions(const Aws::String& value) { m_pendingActionsHasBeenSet = true; m_pendingActions.push_back(value); return *this; }

    /**
     *
A list of cluster operations that are waiting to start.

     */
    inline AwsRedshiftClusterDetails& AddPendingActions(Aws::String&& value) { m_pendingActionsHasBeenSet = true; m_pendingActions.push_back(std::move(value)); return *this; }

    /**
     *
A list of cluster operations that are waiting to start.

     */
    inline AwsRedshiftClusterDetails& AddPendingActions(const char* value) { m_pendingActionsHasBeenSet = true; m_pendingActions.push_back(value); return *this; }

    /**
     *
A list of changes to the cluster that are currently pending.

     */
    inline const AwsRedshiftClusterPendingModifiedValues& GetPendingModifiedValues() const{ return m_pendingModifiedValues; }

    /**
     *
A list of changes to the cluster that are currently pending.

     */
    inline bool PendingModifiedValuesHasBeenSet() const { return m_pendingModifiedValuesHasBeenSet; }

    /**
     *
A list of changes to the cluster that are currently pending.

     */
    inline void SetPendingModifiedValues(const AwsRedshiftClusterPendingModifiedValues& value) { m_pendingModifiedValuesHasBeenSet = true; m_pendingModifiedValues = value; }

    /**
     *
A list of changes to the cluster that are currently pending.

     */
    inline void SetPendingModifiedValues(AwsRedshiftClusterPendingModifiedValues&& value) { m_pendingModifiedValuesHasBeenSet = true; m_pendingModifiedValues = std::move(value); }

    /**
     *
A list of changes to the cluster that are currently pending.

     */
    inline AwsRedshiftClusterDetails& WithPendingModifiedValues(const AwsRedshiftClusterPendingModifiedValues& value) { SetPendingModifiedValues(value); return *this;}

    /**
     *
A list of changes to the cluster that are currently pending.

     */
    inline AwsRedshiftClusterDetails& WithPendingModifiedValues(AwsRedshiftClusterPendingModifiedValues&& value) { SetPendingModifiedValues(std::move(value)); return *this;}

    /**
     *
The weekly time range, in Universal Coordinated Time (UTC), during which
     * system maintenance can occur.

Format:
     * <day>:HH:MM-<day>:HH:MM

For the day
     * values, use mon | tue | wed |
     * thu | fri | sat | sun

     *
For example, sun:09:32-sun:10:02

     */
    inline const Aws::String& GetPreferredMaintenanceWindow() const{ return m_preferredMaintenanceWindow; }

    /**
     *
The weekly time range, in Universal Coordinated Time (UTC), during which
     * system maintenance can occur.

Format:
     * <day>:HH:MM-<day>:HH:MM

For the day
     * values, use mon | tue | wed |
     * thu | fri | sat | sun

     *
For example, sun:09:32-sun:10:02

     */
    inline bool PreferredMaintenanceWindowHasBeenSet() const { return m_preferredMaintenanceWindowHasBeenSet; }

    /**
     *
The weekly time range, in Universal Coordinated Time (UTC), during which
     * system maintenance can occur.

Format:
     * <day>:HH:MM-<day>:HH:MM

For the day
     * values, use mon | tue | wed |
     * thu | fri | sat | sun

     *
For example, sun:09:32-sun:10:02

     */
    inline void SetPreferredMaintenanceWindow(const Aws::String& value) { m_preferredMaintenanceWindowHasBeenSet = true; m_preferredMaintenanceWindow = value; }

    /**
     *
The weekly time range, in Universal Coordinated Time (UTC), during which
     * system maintenance can occur.

Format:
     * <day>:HH:MM-<day>:HH:MM

For the day
     * values, use mon | tue | wed |
     * thu | fri | sat | sun

     *
For example, sun:09:32-sun:10:02

     */
    inline void SetPreferredMaintenanceWindow(Aws::String&& value) { m_preferredMaintenanceWindowHasBeenSet = true; m_preferredMaintenanceWindow = std::move(value); }

    /**
     *
The weekly time range, in Universal Coordinated Time (UTC), during which
     * system maintenance can occur.

Format:
     * <day>:HH:MM-<day>:HH:MM

For the day
     * values, use mon | tue | wed |
     * thu | fri | sat | sun

     *
For example, sun:09:32-sun:10:02

     */
    inline void SetPreferredMaintenanceWindow(const char* value) { m_preferredMaintenanceWindowHasBeenSet = true; m_preferredMaintenanceWindow.assign(value); }

    /**
     *
The weekly time range, in Universal Coordinated Time (UTC), during which
     * system maintenance can occur.

Format:
     * <day>:HH:MM-<day>:HH:MM

For the day
     * values, use mon | tue | wed |
     * thu | fri | sat | sun

     *
For example, sun:09:32-sun:10:02

     */
    inline AwsRedshiftClusterDetails& WithPreferredMaintenanceWindow(const Aws::String& value) { SetPreferredMaintenanceWindow(value); return *this;}

    /**
     *
The weekly time range, in Universal Coordinated Time (UTC), during which
     * system maintenance can occur.

Format:
     * <day>:HH:MM-<day>:HH:MM

For the day
     * values, use mon | tue | wed |
     * thu | fri | sat | sun

     *
For example, sun:09:32-sun:10:02

     */
    inline AwsRedshiftClusterDetails& WithPreferredMaintenanceWindow(Aws::String&& value) { SetPreferredMaintenanceWindow(std::move(value)); return *this;}

    /**
     *
The weekly time range, in Universal Coordinated Time (UTC), during which
     * system maintenance can occur.

Format:
     * <day>:HH:MM-<day>:HH:MM

For the day
     * values, use mon | tue | wed |
     * thu | fri | sat | sun

     *
For example, sun:09:32-sun:10:02

     */
    inline AwsRedshiftClusterDetails& WithPreferredMaintenanceWindow(const char* value) { SetPreferredMaintenanceWindow(value); return *this;}

    /**
     *
Whether the cluster can be accessed from a public network.

     */
    inline bool GetPubliclyAccessible() const{ return m_publiclyAccessible; }

    /**
     *
Whether the cluster can be accessed from a public network.

     */
    inline bool PubliclyAccessibleHasBeenSet() const { return m_publiclyAccessibleHasBeenSet; }

    /**
     *
Whether the cluster can be accessed from a public network.

     */
    inline void SetPubliclyAccessible(bool value) { m_publiclyAccessibleHasBeenSet = true; m_publiclyAccessible = value; }

    /**
     *
Whether the cluster can be accessed from a public network.

     */
    inline AwsRedshiftClusterDetails& WithPubliclyAccessible(bool value) { SetPubliclyAccessible(value); return *this;}

    /**
     *
Information about the resize operation for the cluster.

     */
    inline const AwsRedshiftClusterResizeInfo& GetResizeInfo() const{ return m_resizeInfo; }

    /**
     *
Information about the resize operation for the cluster.

     */
    inline bool ResizeInfoHasBeenSet() const { return m_resizeInfoHasBeenSet; }

    /**
     *
Information about the resize operation for the cluster.

     */
    inline void SetResizeInfo(const AwsRedshiftClusterResizeInfo& value) { m_resizeInfoHasBeenSet = true; m_resizeInfo = value; }

    /**
     *
Information about the resize operation for the cluster.

     */
    inline void SetResizeInfo(AwsRedshiftClusterResizeInfo&& value) { m_resizeInfoHasBeenSet = true; m_resizeInfo = std::move(value); }

    /**
     *
Information about the resize operation for the cluster.

     */
    inline AwsRedshiftClusterDetails& WithResizeInfo(const AwsRedshiftClusterResizeInfo& value) { SetResizeInfo(value); return *this;}

    /**
     *
Information about the resize operation for the cluster.

     */
    inline AwsRedshiftClusterDetails& WithResizeInfo(AwsRedshiftClusterResizeInfo&& value) { SetResizeInfo(std::move(value)); return *this;}

    /**
     *
Information about the status of a cluster restore action. Only applies to a
     * cluster that was created by restoring a snapshot.

     */
    inline const AwsRedshiftClusterRestoreStatus& GetRestoreStatus() const{ return m_restoreStatus; }

    /**
     *
Information about the status of a cluster restore action. Only applies to a
     * cluster that was created by restoring a snapshot.

     */
    inline bool RestoreStatusHasBeenSet() const { return m_restoreStatusHasBeenSet; }

    /**
     *
Information about the status of a cluster restore action. Only applies to a
     * cluster that was created by restoring a snapshot.

     */
    inline void SetRestoreStatus(const AwsRedshiftClusterRestoreStatus& value) { m_restoreStatusHasBeenSet = true; m_restoreStatus = value; }

    /**
     *
Information about the status of a cluster restore action. Only applies to a
     * cluster that was created by restoring a snapshot.

     */
    inline void SetRestoreStatus(AwsRedshiftClusterRestoreStatus&& value) { m_restoreStatusHasBeenSet = true; m_restoreStatus = std::move(value); }

    /**
     *
Information about the status of a cluster restore action. Only applies to a
     * cluster that was created by restoring a snapshot.

     */
    inline AwsRedshiftClusterDetails& WithRestoreStatus(const AwsRedshiftClusterRestoreStatus& value) { SetRestoreStatus(value); return *this;}

    /**
     *
Information about the status of a cluster restore action. Only applies to a
     * cluster that was created by restoring a snapshot.

     */
    inline AwsRedshiftClusterDetails& WithRestoreStatus(AwsRedshiftClusterRestoreStatus&& value) { SetRestoreStatus(std::move(value)); return *this;}

    /**
     *
A unique identifier for the cluster snapshot schedule.

     */
    inline const Aws::String& GetSnapshotScheduleIdentifier() const{ return m_snapshotScheduleIdentifier; }

    /**
     *
A unique identifier for the cluster snapshot schedule.

     */
    inline bool SnapshotScheduleIdentifierHasBeenSet() const { return m_snapshotScheduleIdentifierHasBeenSet; }

    /**
     *
A unique identifier for the cluster snapshot schedule.

     */
    inline void SetSnapshotScheduleIdentifier(const Aws::String& value) { m_snapshotScheduleIdentifierHasBeenSet = true; m_snapshotScheduleIdentifier = value; }

    /**
     *
A unique identifier for the cluster snapshot schedule.

     */
    inline void SetSnapshotScheduleIdentifier(Aws::String&& value) { m_snapshotScheduleIdentifierHasBeenSet = true; m_snapshotScheduleIdentifier = std::move(value); }

    /**
     *
A unique identifier for the cluster snapshot schedule.

     */
    inline void SetSnapshotScheduleIdentifier(const char* value) { m_snapshotScheduleIdentifierHasBeenSet = true; m_snapshotScheduleIdentifier.assign(value); }

    /**
     *
A unique identifier for the cluster snapshot schedule.

     */
    inline AwsRedshiftClusterDetails& WithSnapshotScheduleIdentifier(const Aws::String& value) { SetSnapshotScheduleIdentifier(value); return *this;}

    /**
     *
A unique identifier for the cluster snapshot schedule.

     */
    inline AwsRedshiftClusterDetails& WithSnapshotScheduleIdentifier(Aws::String&& value) { SetSnapshotScheduleIdentifier(std::move(value)); return *this;}

    /**
     *
A unique identifier for the cluster snapshot schedule.

     */
    inline AwsRedshiftClusterDetails& WithSnapshotScheduleIdentifier(const char* value) { SetSnapshotScheduleIdentifier(value); return *this;}

    /**
     *
The current state of the cluster snapshot schedule.

Valid values:
     * MODIFYING | ACTIVE | FAILED

     */
    inline const Aws::String& GetSnapshotScheduleState() const{ return m_snapshotScheduleState; }

    /**
     *
The current state of the cluster snapshot schedule.

Valid values:
     * MODIFYING | ACTIVE | FAILED

     */
    inline bool SnapshotScheduleStateHasBeenSet() const { return m_snapshotScheduleStateHasBeenSet; }

    /**
     *
The current state of the cluster snapshot schedule.

Valid values:
     * MODIFYING | ACTIVE | FAILED

     */
    inline void SetSnapshotScheduleState(const Aws::String& value) { m_snapshotScheduleStateHasBeenSet = true; m_snapshotScheduleState = value; }

    /**
     *
The current state of the cluster snapshot schedule.

Valid values:
     * MODIFYING | ACTIVE | FAILED

     */
    inline void SetSnapshotScheduleState(Aws::String&& value) { m_snapshotScheduleStateHasBeenSet = true; m_snapshotScheduleState = std::move(value); }

    /**
     *
The current state of the cluster snapshot schedule.

Valid values:
     * MODIFYING | ACTIVE | FAILED

     */
    inline void SetSnapshotScheduleState(const char* value) { m_snapshotScheduleStateHasBeenSet = true; m_snapshotScheduleState.assign(value); }

    /**
     *
The current state of the cluster snapshot schedule.

Valid values:
     * MODIFYING | ACTIVE | FAILED

     */
    inline AwsRedshiftClusterDetails& WithSnapshotScheduleState(const Aws::String& value) { SetSnapshotScheduleState(value); return *this;}

    /**
     *
The current state of the cluster snapshot schedule.

Valid values:
     * MODIFYING | ACTIVE | FAILED

     */
    inline AwsRedshiftClusterDetails& WithSnapshotScheduleState(Aws::String&& value) { SetSnapshotScheduleState(std::move(value)); return *this;}

    /**
     *
The current state of the cluster snapshot schedule.

Valid values:
     * MODIFYING | ACTIVE | FAILED

     */
    inline AwsRedshiftClusterDetails& WithSnapshotScheduleState(const char* value) { SetSnapshotScheduleState(value); return *this;}

    /**
     *
The identifier of the VPC that the cluster is in, if the cluster is in a
     * VPC.

     */
    inline const Aws::String& GetVpcId() const{ return m_vpcId; }

    /**
     *
The identifier of the VPC that the cluster is in, if the cluster is in a
     * VPC.

     */
    inline bool VpcIdHasBeenSet() const { return m_vpcIdHasBeenSet; }

    /**
     *
The identifier of the VPC that the cluster is in, if the cluster is in a
     * VPC.

     */
    inline void SetVpcId(const Aws::String& value) { m_vpcIdHasBeenSet = true; m_vpcId = value; }

    /**
     *
The identifier of the VPC that the cluster is in, if the cluster is in a
     * VPC.

     */
    inline void SetVpcId(Aws::String&& value) { m_vpcIdHasBeenSet = true; m_vpcId = std::move(value); }

    /**
     *
The identifier of the VPC that the cluster is in, if the cluster is in a
     * VPC.

     */
    inline void SetVpcId(const char* value) { m_vpcIdHasBeenSet = true; m_vpcId.assign(value); }

    /**
     *
The identifier of the VPC that the cluster is in, if the cluster is in a
     * VPC.

     */
    inline AwsRedshiftClusterDetails& WithVpcId(const Aws::String& value) { SetVpcId(value); return *this;}

    /**
     *
The identifier of the VPC that the cluster is in, if the cluster is in a
     * VPC.

     */
    inline AwsRedshiftClusterDetails& WithVpcId(Aws::String&& value) { SetVpcId(std::move(value)); return *this;}

    /**
     *
The identifier of the VPC that the cluster is in, if the cluster is in a
     * VPC.

     */
    inline AwsRedshiftClusterDetails& WithVpcId(const char* value) { SetVpcId(value); return *this;}

    /**
     *
The list of VPC security groups that the cluster belongs to, if the cluster
     * is in a VPC.

     */
    inline const Aws::Vector<AwsRedshiftClusterVpcSecurityGroup>& GetVpcSecurityGroups() const{ return m_vpcSecurityGroups; }

    /**
     *
The list of VPC security groups that the cluster belongs to, if the cluster
     * is in a VPC.

     */
    inline bool VpcSecurityGroupsHasBeenSet() const { return m_vpcSecurityGroupsHasBeenSet; }

    /**
     *
The list of VPC security groups that the cluster belongs to, if the cluster
     * is in a VPC.

     */
    inline void SetVpcSecurityGroups(const Aws::Vector<AwsRedshiftClusterVpcSecurityGroup>& value) { m_vpcSecurityGroupsHasBeenSet = true; m_vpcSecurityGroups = value; }

    /**
     *
The list of VPC security groups that the cluster belongs to, if the cluster
     * is in a VPC.

     */
    inline void SetVpcSecurityGroups(Aws::Vector<AwsRedshiftClusterVpcSecurityGroup>&& value) { m_vpcSecurityGroupsHasBeenSet = true; m_vpcSecurityGroups = std::move(value); }

    /**
     *
The list of VPC security groups that the cluster belongs to, if the cluster
     * is in a VPC.

     */
    inline AwsRedshiftClusterDetails& WithVpcSecurityGroups(const Aws::Vector<AwsRedshiftClusterVpcSecurityGroup>& value) { SetVpcSecurityGroups(value); return *this;}

    /**
     *
The list of VPC security groups that the cluster belongs to, if the cluster
     * is in a VPC.

     */
    inline AwsRedshiftClusterDetails& WithVpcSecurityGroups(Aws::Vector<AwsRedshiftClusterVpcSecurityGroup>&& value) { SetVpcSecurityGroups(std::move(value)); return *this;}

    /**
     *
The list of VPC security groups that the cluster belongs to, if the cluster
     * is in a VPC.

     */
    inline AwsRedshiftClusterDetails& AddVpcSecurityGroups(const AwsRedshiftClusterVpcSecurityGroup& value) { m_vpcSecurityGroupsHasBeenSet = true; m_vpcSecurityGroups.push_back(value); return *this; }

    /**
     *
The list of VPC security groups that the cluster belongs to, if the cluster
     * is in a VPC.

     */
    inline AwsRedshiftClusterDetails& AddVpcSecurityGroups(AwsRedshiftClusterVpcSecurityGroup&& value) { m_vpcSecurityGroupsHasBeenSet = true; m_vpcSecurityGroups.push_back(std::move(value)); return *this; }

  private:

    bool m_allowVersionUpgrade;
    bool m_allowVersionUpgradeHasBeenSet;

    int m_automatedSnapshotRetentionPeriod;
    bool m_automatedSnapshotRetentionPeriodHasBeenSet;

    Aws::String m_availabilityZone;
    bool m_availabilityZoneHasBeenSet;

    Aws::String m_clusterAvailabilityStatus;
    bool m_clusterAvailabilityStatusHasBeenSet;

    Aws::String m_clusterCreateTime;
    bool m_clusterCreateTimeHasBeenSet;

    Aws::String m_clusterIdentifier;
    bool m_clusterIdentifierHasBeenSet;

    Aws::Vector<AwsRedshiftClusterClusterNode> m_clusterNodes;
    bool m_clusterNodesHasBeenSet;

    Aws::Vector<AwsRedshiftClusterClusterParameterGroup> m_clusterParameterGroups;
    bool m_clusterParameterGroupsHasBeenSet;

    Aws::String m_clusterPublicKey;
    bool m_clusterPublicKeyHasBeenSet;

    Aws::String m_clusterRevisionNumber;
    bool m_clusterRevisionNumberHasBeenSet;

    Aws::Vector<AwsRedshiftClusterClusterSecurityGroup> m_clusterSecurityGroups;
    bool m_clusterSecurityGroupsHasBeenSet;

    AwsRedshiftClusterClusterSnapshotCopyStatus m_clusterSnapshotCopyStatus;
    bool m_clusterSnapshotCopyStatusHasBeenSet;

    Aws::String m_clusterStatus;
    bool m_clusterStatusHasBeenSet;

    Aws::String m_clusterSubnetGroupName;
    bool m_clusterSubnetGroupNameHasBeenSet;

    Aws::String m_clusterVersion;
    bool m_clusterVersionHasBeenSet;

    Aws::String m_dBName;
    bool m_dBNameHasBeenSet;

    Aws::Vector<AwsRedshiftClusterDeferredMaintenanceWindow> m_deferredMaintenanceWindows;
    bool m_deferredMaintenanceWindowsHasBeenSet;

    AwsRedshiftClusterElasticIpStatus m_elasticIpStatus;
    bool m_elasticIpStatusHasBeenSet;

    Aws::String m_elasticResizeNumberOfNodeOptions;
    bool m_elasticResizeNumberOfNodeOptionsHasBeenSet;

    bool m_encrypted;
    bool m_encryptedHasBeenSet;

    AwsRedshiftClusterEndpoint m_endpoint;
    bool m_endpointHasBeenSet;

    bool m_enhancedVpcRouting;
    bool m_enhancedVpcRoutingHasBeenSet;

    Aws::String m_expectedNextSnapshotScheduleTime;
    bool m_expectedNextSnapshotScheduleTimeHasBeenSet;

    Aws::String m_expectedNextSnapshotScheduleTimeStatus;
    bool m_expectedNextSnapshotScheduleTimeStatusHasBeenSet;

    AwsRedshiftClusterHsmStatus m_hsmStatus;
    bool m_hsmStatusHasBeenSet;

    Aws::Vector<AwsRedshiftClusterIamRole> m_iamRoles;
    bool m_iamRolesHasBeenSet;

    Aws::String m_kmsKeyId;
    bool m_kmsKeyIdHasBeenSet;

    Aws::String m_maintenanceTrackName;
    bool m_maintenanceTrackNameHasBeenSet;

    int m_manualSnapshotRetentionPeriod;
    bool m_manualSnapshotRetentionPeriodHasBeenSet;

    Aws::String m_masterUsername;
    bool m_masterUsernameHasBeenSet;

    Aws::String m_nextMaintenanceWindowStartTime;
    bool m_nextMaintenanceWindowStartTimeHasBeenSet;

    Aws::String m_nodeType;
    bool m_nodeTypeHasBeenSet;

    int m_numberOfNodes;
    bool m_numberOfNodesHasBeenSet;

    Aws::Vector<Aws::String> m_pendingActions;
    bool m_pendingActionsHasBeenSet;

    AwsRedshiftClusterPendingModifiedValues m_pendingModifiedValues;
    bool m_pendingModifiedValuesHasBeenSet;

    Aws::String m_preferredMaintenanceWindow;
    bool m_preferredMaintenanceWindowHasBeenSet;

    bool m_publiclyAccessible;
    bool m_publiclyAccessibleHasBeenSet;

    AwsRedshiftClusterResizeInfo m_resizeInfo;
    bool m_resizeInfoHasBeenSet;

    AwsRedshiftClusterRestoreStatus m_restoreStatus;
    bool m_restoreStatusHasBeenSet;

    Aws::String m_snapshotScheduleIdentifier;
    bool m_snapshotScheduleIdentifierHasBeenSet;

    Aws::String m_snapshotScheduleState;
    bool m_snapshotScheduleStateHasBeenSet;

    Aws::String m_vpcId;
    bool m_vpcIdHasBeenSet;

    Aws::Vector<AwsRedshiftClusterVpcSecurityGroup> m_vpcSecurityGroups;
    bool m_vpcSecurityGroupsHasBeenSet;
  };

} // namespace Model
} // namespace SecurityHub
} // namespace Aws


text:
@interface JMFSKRecognizer : NSObject <JMPatternRecognizer>

@property (nonatomic, weak) NSObject<JMFSKRecognizerDelegate>* delegate;

-(instancetype)initWithConfiguration:(JMFSKModemConfiguration*)configuration;

@end

redpajama_set_name: RedPajamaGithub


text:
import sys, os
import sphinx_rtd_theme

sys.path.insert(0, os.path.abspath('..'))
from manage import init_hq_python_path, run_patches

import settings
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "settings")
# this avoids having to import corehq.util.log.HQRequestFilter which has a chained dependency
# to OpenSSL
settings.LOGGING = {}
init_hq_python_path()
run_patches()

# -- Custom configuration -----------------------------------------------------

# mock out stubborn modules that are hard to pip install
# https://docs.readthedocs.org/en/latest/faq.html#i-get-import-errors-on-libraries-that-depend-on-c-modules
autodoc_mock_imports = ["OpenSSL", "onelogin"]

# The suffix of source filenames.
source_suffix = ['.rst', '.md']

# -- General configuration -----------------------------------------------------

# If your documentation needs a minimal Sphinx version, state it here.
#needs_sphinx = '1.0'

# Add any Sphinx extension module names here, as strings. They can be extensions
# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
extensions = [
    'myst_parser',
    'sphinx.ext.autodoc',
    'sphinx.ext.viewcode',
    'sphinxcontrib_django',
]

# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']

# The master toctree document.
master_doc = 'index'

# General information about the project.
project = 'CommCareHQ'
copyright = '2020, Dimagi'

version = '1.0'
release = '1.0'

# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = ['_build']

# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'

# -- Options for HTML output ---------------------------------------------------

# The theme to use for HTML and HTML Help pages.  See the documentation for
# a list of builtin themes.
#  html_theme = 'default'
html_theme = "sphinx_rtd_theme"

# Add any paths that contain custom themes here, relative to this directory.
#html_theme_path = []
html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]

# Output file base name for HTML help builder.
htmlhelp_basename = 'CommCareHQdoc'

# -- Options for LaTeX output --------------------------------------------------

latex_elements = {
}

# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title, author, documentclass [howto/manual]).
latex_documents = [
  ('index', 'CommCareHQ.tex', 'CommCareHQ Documentation',
   'Dimagi', 'manual'),
]

# -- Options for manual page output --------------------------------------------

# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
    ('index', 'commcarehq', 'CommCareHQ Documentation',
     ['Dimagi'], 1)
]

# -- Options for Texinfo output ------------------------------------------------

# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
#  dir menu entry, description, category)
texinfo_documents = [
  ('index', 'CommCareHQ', 'CommCareHQ Documentation',
   'Dimagi', 'CommCareHQ', 'One line description of project.',
   'Miscellaneous'),
]