text:
InicioSingaporeEntradasMuseosNational Museum of Singapore Tickets
National Museum of Singapore Tickets - Foreign Citizens
(155 Valoraciones)
National Museum of Singapore is here to take you back in time and rediscover the history of the metropolitan land that Singapore is today.
Founded in 1887, this is Singapore's oldest museum, discover the history of the city at National Museum of Singapore.
Enjoy one full day exploring over 1,700 artifacts preserved through history.
Be a part of the many informative and fun exhibitions that the museum hosts.
Learn about the history of Singapore from its inception to daily life now.
Fun fact: A fragment of the Singapore Stone, which is a relic of of one of the oldest inscriptions discovered in the city, is also present at the museum.
Entry to National Museum of Singapore
Puedes cancelar estas entradas hasta 24 horas antes del comienzo de la experiencia y recibir un reembolso completo.
Dating back to 1887, the National Museum of Singapore is the country's oldest museum and currently holds more 1,700 cultural and historical artefacts. The building itself is an architectural marvel, and now the galleries have adopted the latest technologies in their displays and exhibitions. Learn all about the quaint beginnings of Singapore to its status of a global metropolis today. Walk into any of the frequent exhibitions, screenings, talks, festivals, etc that the museum hosts all year round.
This ticket is valid only for foreign citizens.
Admission is free for Singapore citizens, permanent residents, and children aged 6 and under (of any nationality).
Admission is free for all visitors on 1 Jan 2023, 4 Feb 2023, 18 May 2023, and 27 & 28 May 2023.
Daily: 10am - 7pm
Your voucher will be emailed to you shortly. Please display the same on your mobile phone with a valid photo ID.
These tickets are valid for 6 months from the date of purchase and can be used anytime between the operating hours within the validity period.
Singapore River Cruise
S$28S$25.50
Ahorra hasta un 8%


text:
#pragma once
#include <aws/redshift/Redshift_EXPORTS.h>
#include <aws/redshift/RedshiftRequest.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <utility>

namespace Aws
{
namespace Redshift
{
namespace Model
{

  /**
   *

See Also:
   AWS
   * API Reference

   */
  class AWS_REDSHIFT_API ModifyClusterRequest : public RedshiftRequest
  {
  public:
    ModifyClusterRequest();

    // Service request name is the Operation name which will send this request out,
    // each operation should has unique request name, so that we can get operation's name from this request.
    // Note: this is not true for response, multiple operations may have the same response name,
    // so we can not get operation's name from response.
    inline virtual const char* GetServiceRequestName() const override { return "ModifyCluster"; }

    Aws::String SerializePayload() const override;

  protected:
    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;

  public:

    /**
     *
The unique identifier of the cluster to be modified.

Example:
     * examplecluster

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

    /**
     *
The unique identifier of the cluster to be modified.

Example:
     * examplecluster

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

    /**
     *
The unique identifier of the cluster to be modified.

Example:
     * examplecluster

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

    /**
     *
The unique identifier of the cluster to be modified.

Example:
     * examplecluster

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

    /**
     *
The unique identifier of the cluster to be modified.

Example:
     * examplecluster

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

    /**
     *
The unique identifier of the cluster to be modified.

Example:
     * examplecluster

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

    /**
     *
The unique identifier of the cluster to be modified.

Example:
     * examplecluster

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

    /**
     *
The unique identifier of the cluster to be modified.

Example:
     * examplecluster

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

    /**
     *
The new cluster type.

When you submit your cluster resize request,
     * your existing cluster goes into a read-only mode. After Amazon Redshift
     * provisions a new cluster based on your resize requirements, there will be outage
     * for a period while the old cluster is deleted and your connection is switched to
     * the new cluster. You can use DescribeResize to track the progress of the
     * resize request.

Valid Values:  multi-node | single-node
     *

     */
    inline const Aws::String& GetClusterType() const{ return m_clusterType; }

    /**
     *
The new cluster type.

When you submit your cluster resize request,
     * your existing cluster goes into a read-only mode. After Amazon Redshift
     * provisions a new cluster based on your resize requirements, there will be outage
     * for a period while the old cluster is deleted and your connection is switched to
     * the new cluster. You can use DescribeResize to track the progress of the
     * resize request.

Valid Values:  multi-node | single-node
     *

     */
    inline bool ClusterTypeHasBeenSet() const { return m_clusterTypeHasBeenSet; }

    /**
     *
The new cluster type.

When you submit your cluster resize request,
     * your existing cluster goes into a read-only mode. After Amazon Redshift
     * provisions a new cluster based on your resize requirements, there will be outage
     * for a period while the old cluster is deleted and your connection is switched to
     * the new cluster. You can use DescribeResize to track the progress of the
     * resize request.

Valid Values:  multi-node | single-node
     *

     */
    inline void SetClusterType(const Aws::String& value) { m_clusterTypeHasBeenSet = true; m_clusterType = value; }

    /**
     *
The new cluster type.

When you submit your cluster resize request,
     * your existing cluster goes into a read-only mode. After Amazon Redshift
     * provisions a new cluster based on your resize requirements, there will be outage
     * for a period while the old cluster is deleted and your connection is switched to
     * the new cluster. You can use DescribeResize to track the progress of the
     * resize request.

Valid Values:  multi-node | single-node
     *

     */
    inline void SetClusterType(Aws::String&& value) { m_clusterTypeHasBeenSet = true; m_clusterType = std::move(value); }

    /**
     *
The new cluster type.

When you submit your cluster resize request,
     * your existing cluster goes into a read-only mode. After Amazon Redshift
     * provisions a new cluster based on your resize requirements, there will be outage
     * for a period while the old cluster is deleted and your connection is switched to
     * the new cluster. You can use DescribeResize to track the progress of the
     * resize request.

Valid Values:  multi-node | single-node
     *

     */
    inline void SetClusterType(const char* value) { m_clusterTypeHasBeenSet = true; m_clusterType.assign(value); }

    /**
     *
The new cluster type.

When you submit your cluster resize request,
     * your existing cluster goes into a read-only mode. After Amazon Redshift
     * provisions a new cluster based on your resize requirements, there will be outage
     * for a period while the old cluster is deleted and your connection is switched to
     * the new cluster. You can use DescribeResize to track the progress of the
     * resize request.

Valid Values:  multi-node | single-node
     *

     */
    inline ModifyClusterRequest& WithClusterType(const Aws::String& value) { SetClusterType(value); return *this;}

    /**
     *
The new cluster type.

When you submit your cluster resize request,
     * your existing cluster goes into a read-only mode. After Amazon Redshift
     * provisions a new cluster based on your resize requirements, there will be outage
     * for a period while the old cluster is deleted and your connection is switched to
     * the new cluster. You can use DescribeResize to track the progress of the
     * resize request.

Valid Values:  multi-node | single-node
     *

     */
    inline ModifyClusterRequest& WithClusterType(Aws::String&& value) { SetClusterType(std::move(value)); return *this;}

    /**
     *
The new cluster type.

When you submit your cluster resize request,
     * your existing cluster goes into a read-only mode. After Amazon Redshift
     * provisions a new cluster based on your resize requirements, there will be outage
     * for a period while the old cluster is deleted and your connection is switched to
     * the new cluster. You can use DescribeResize to track the progress of the
     * resize request.

Valid Values:  multi-node | single-node
     *

     */
    inline ModifyClusterRequest& WithClusterType(const char* value) { SetClusterType(value); return *this;}

    /**
     *
The new node type of the cluster. If you specify a new node type, you must
     * also specify the number of nodes parameter.

 For more information about
     * resizing clusters, go to Resizing
     * Clusters in Amazon Redshift in the Amazon Redshift Cluster Management
     * Guide.

Valid Values: ds2.xlarge |
     * ds2.8xlarge | dc1.large | dc1.8xlarge |
     * dc2.large | dc2.8xlarge | ra3.xlplus |
     * ra3.4xlarge | ra3.16xlarge

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

    /**
     *
The new node type of the cluster. If you specify a new node type, you must
     * also specify the number of nodes parameter.

 For more information about
     * resizing clusters, go to Resizing
     * Clusters in Amazon Redshift in the Amazon Redshift Cluster Management
     * Guide.

Valid Values: ds2.xlarge |
     * ds2.8xlarge | dc1.large | dc1.8xlarge |
     * dc2.large | dc2.8xlarge | ra3.xlplus |
     * ra3.4xlarge | ra3.16xlarge

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

    /**
     *
The new node type of the cluster. If you specify a new node type, you must
     * also specify the number of nodes parameter.

 For more information about
     * resizing clusters, go to Resizing
     * Clusters in Amazon Redshift in the Amazon Redshift Cluster Management
     * Guide.

Valid Values: ds2.xlarge |
     * ds2.8xlarge | dc1.large | dc1.8xlarge |
     * dc2.large | dc2.8xlarge | ra3.xlplus |
     * ra3.4xlarge | ra3.16xlarge

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

    /**
     *
The new node type of the cluster. If you specify a new node type, you must
     * also specify the number of nodes parameter.

 For more information about
     * resizing clusters, go to Resizing
     * Clusters in Amazon Redshift in the Amazon Redshift Cluster Management
     * Guide.

Valid Values: ds2.xlarge |
     * ds2.8xlarge | dc1.large | dc1.8xlarge |
     * dc2.large | dc2.8xlarge | ra3.xlplus |
     * ra3.4xlarge | ra3.16xlarge

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

    /**
     *
The new node type of the cluster. If you specify a new node type, you must
     * also specify the number of nodes parameter.

 For more information about
     * resizing clusters, go to Resizing
     * Clusters in Amazon Redshift in the Amazon Redshift Cluster Management
     * Guide.

Valid Values: ds2.xlarge |
     * ds2.8xlarge | dc1.large | dc1.8xlarge |
     * dc2.large | dc2.8xlarge | ra3.xlplus |
     * ra3.4xlarge | ra3.16xlarge

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

    /**
     *
The new node type of the cluster. If you specify a new node type, you must
     * also specify the number of nodes parameter.

 For more information about
     * resizing clusters, go to Resizing
     * Clusters in Amazon Redshift in the Amazon Redshift Cluster Management
     * Guide.

Valid Values: ds2.xlarge |
     * ds2.8xlarge | dc1.large | dc1.8xlarge |
     * dc2.large | dc2.8xlarge | ra3.xlplus |
     * ra3.4xlarge | ra3.16xlarge

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

    /**
     *
The new node type of the cluster. If you specify a new node type, you must
     * also specify the number of nodes parameter.

 For more information about
     * resizing clusters, go to Resizing
     * Clusters in Amazon Redshift in the Amazon Redshift Cluster Management
     * Guide.

Valid Values: ds2.xlarge |
     * ds2.8xlarge | dc1.large | dc1.8xlarge |
     * dc2.large | dc2.8xlarge | ra3.xlplus |
     * ra3.4xlarge | ra3.16xlarge

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

    /**
     *
The new node type of the cluster. If you specify a new node type, you must
     * also specify the number of nodes parameter.

 For more information about
     * resizing clusters, go to Resizing
     * Clusters in Amazon Redshift in the Amazon Redshift Cluster Management
     * Guide.

Valid Values: ds2.xlarge |
     * ds2.8xlarge | dc1.large | dc1.8xlarge |
     * dc2.large | dc2.8xlarge | ra3.xlplus |
     * ra3.4xlarge | ra3.16xlarge

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

    /**
     *
The new number of nodes of the cluster. If you specify a new number of nodes,
     * you must also specify the node type parameter.

 For more information
     * about resizing clusters, go to Resizing
     * Clusters in Amazon Redshift in the Amazon Redshift Cluster Management
     * Guide.

Valid Values: Integer greater than 0.

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

    /**
     *
The new number of nodes of the cluster. If you specify a new number of nodes,
     * you must also specify the node type parameter.

 For more information
     * about resizing clusters, go to Resizing
     * Clusters in Amazon Redshift in the Amazon Redshift Cluster Management
     * Guide.

Valid Values: Integer greater than 0.

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

    /**
     *
The new number of nodes of the cluster. If you specify a new number of nodes,
     * you must also specify the node type parameter.

 For more information
     * about resizing clusters, go to Resizing
     * Clusters in Amazon Redshift in the Amazon Redshift Cluster Management
     * Guide.

Valid Values: Integer greater than 0.

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

    /**
     *
The new number of nodes of the cluster. If you specify a new number of nodes,
     * you must also specify the node type parameter.

 For more information
     * about resizing clusters, go to Resizing
     * Clusters in Amazon Redshift in the Amazon Redshift Cluster Management
     * Guide.

Valid Values: Integer greater than 0.

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

    /**
     *
A list of cluster security groups to be authorized on this cluster. This
     * change is asynchronously applied as soon as possible.

Security groups
     * currently associated with the cluster, and not in the list of groups to apply,
     * will be revoked from the cluster.

Constraints:

Must be 1
     * to 255 alphanumeric characters or hyphens

First character must
     * be a letter

Cannot end with a hyphen or contain two
     * consecutive hyphens

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

    /**
     *
A list of cluster security groups to be authorized on this cluster. This
     * change is asynchronously applied as soon as possible.

Security groups
     * currently associated with the cluster, and not in the list of groups to apply,
     * will be revoked from the cluster.

Constraints:

Must be 1
     * to 255 alphanumeric characters or hyphens

First character must
     * be a letter

Cannot end with a hyphen or contain two
     * consecutive hyphens

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

    /**
     *
A list of cluster security groups to be authorized on this cluster. This
     * change is asynchronously applied as soon as possible.

Security groups
     * currently associated with the cluster, and not in the list of groups to apply,
     * will be revoked from the cluster.

Constraints:

Must be 1
     * to 255 alphanumeric characters or hyphens

First character must
     * be a letter

Cannot end with a hyphen or contain two
     * consecutive hyphens

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

    /**
     *
A list of cluster security groups to be authorized on this cluster. This
     * change is asynchronously applied as soon as possible.

Security groups
     * currently associated with the cluster, and not in the list of groups to apply,
     * will be revoked from the cluster.

Constraints:

Must be 1
     * to 255 alphanumeric characters or hyphens

First character must
     * be a letter

Cannot end with a hyphen or contain two
     * consecutive hyphens

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

    /**
     *
A list of cluster security groups to be authorized on this cluster. This
     * change is asynchronously applied as soon as possible.

Security groups
     * currently associated with the cluster, and not in the list of groups to apply,
     * will be revoked from the cluster.

Constraints:

Must be 1
     * to 255 alphanumeric characters or hyphens

First character must
     * be a letter

Cannot end with a hyphen or contain two
     * consecutive hyphens

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

    /**
     *
A list of cluster security groups to be authorized on this cluster. This
     * change is asynchronously applied as soon as possible.

Security groups
     * currently associated with the cluster, and not in the list of groups to apply,
     * will be revoked from the cluster.

Constraints:

Must be 1
     * to 255 alphanumeric characters or hyphens

First character must
     * be a letter

Cannot end with a hyphen or contain two
     * consecutive hyphens

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

    /**
     *
A list of cluster security groups to be authorized on this cluster. This
     * change is asynchronously applied as soon as possible.

Security groups
     * currently associated with the cluster, and not in the list of groups to apply,
     * will be revoked from the cluster.

Constraints:

Must be 1
     * to 255 alphanumeric characters or hyphens

First character must
     * be a letter

Cannot end with a hyphen or contain two
     * consecutive hyphens

     */
    inline ModifyClusterRequest& AddClusterSecurityGroups(const Aws::String& value) { m_clusterSecurityGroupsHasBeenSet = true; m_clusterSecurityGroups.push_back(value); return *this; }

    /**
     *
A list of cluster security groups to be authorized on this cluster. This
     * change is asynchronously applied as soon as possible.

Security groups
     * currently associated with the cluster, and not in the list of groups to apply,
     * will be revoked from the cluster.

Constraints:

Must be 1
     * to 255 alphanumeric characters or hyphens

First character must
     * be a letter

Cannot end with a hyphen or contain two
     * consecutive hyphens

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

    /**
     *
A list of cluster security groups to be authorized on this cluster. This
     * change is asynchronously applied as soon as possible.

Security groups
     * currently associated with the cluster, and not in the list of groups to apply,
     * will be revoked from the cluster.

Constraints:

Must be 1
     * to 255 alphanumeric characters or hyphens

First character must
     * be a letter

Cannot end with a hyphen or contain two
     * consecutive hyphens

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

    /**
     *
A list of virtual private cloud (VPC) security groups to be associated with
     * the cluster. This change is asynchronously applied as soon as possible.

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

    /**
     *
A list of virtual private cloud (VPC) security groups to be associated with
     * the cluster. This change is asynchronously applied as soon as possible.

     */
    inline bool VpcSecurityGroupIdsHasBeenSet() const { return m_vpcSecurityGroupIdsHasBeenSet; }

    /**
     *
A list of virtual private cloud (VPC) security groups to be associated with
     * the cluster. This change is asynchronously applied as soon as possible.

     */
    inline void SetVpcSecurityGroupIds(const Aws::Vector<Aws::String>& value) { m_vpcSecurityGroupIdsHasBeenSet = true; m_vpcSecurityGroupIds = value; }

    /**
     *
A list of virtual private cloud (VPC) security groups to be associated with
     * the cluster. This change is asynchronously applied as soon as possible.

     */
    inline void SetVpcSecurityGroupIds(Aws::Vector<Aws::String>&& value) { m_vpcSecurityGroupIdsHasBeenSet = true; m_vpcSecurityGroupIds = std::move(value); }

    /**
     *
A list of virtual private cloud (VPC) security groups to be associated with
     * the cluster. This change is asynchronously applied as soon as possible.

     */
    inline ModifyClusterRequest& WithVpcSecurityGroupIds(const Aws::Vector<Aws::String>& value) { SetVpcSecurityGroupIds(value); return *this;}

    /**
     *
A list of virtual private cloud (VPC) security groups to be associated with
     * the cluster. This change is asynchronously applied as soon as possible.

     */
    inline ModifyClusterRequest& WithVpcSecurityGroupIds(Aws::Vector<Aws::String>&& value) { SetVpcSecurityGroupIds(std::move(value)); return *this;}

    /**
     *
A list of virtual private cloud (VPC) security groups to be associated with
     * the cluster. This change is asynchronously applied as soon as possible.

     */
    inline ModifyClusterRequest& AddVpcSecurityGroupIds(const Aws::String& value) { m_vpcSecurityGroupIdsHasBeenSet = true; m_vpcSecurityGroupIds.push_back(value); return *this; }

    /**
     *
A list of virtual private cloud (VPC) security groups to be associated with
     * the cluster. This change is asynchronously applied as soon as possible.

     */
    inline ModifyClusterRequest& AddVpcSecurityGroupIds(Aws::String&& value) { m_vpcSecurityGroupIdsHasBeenSet = true; m_vpcSecurityGroupIds.push_back(std::move(value)); return *this; }

    /**
     *
A list of virtual private cloud (VPC) security groups to be associated with
     * the cluster. This change is asynchronously applied as soon as possible.

     */
    inline ModifyClusterRequest& AddVpcSecurityGroupIds(const char* value) { m_vpcSecurityGroupIdsHasBeenSet = true; m_vpcSecurityGroupIds.push_back(value); return *this; }

    /**
     *
The new password for the cluster admin user. This change is asynchronously
     * applied as soon as possible. Between the time of the request and the completion
     * of the request, the MasterUserPassword element exists in the
     * PendingModifiedValues element of the operation response.

     *
Operations never return the password, so this operation provides a way
     * to regain access to the admin user account for a cluster if the password is
     * lost.

Default: Uses existing setting.

Constraints:

     *

Must be between 8 and 64 characters in length.

     *
Must contain at least one uppercase letter.

Must contain at
     * least one lowercase letter.

Must contain one number.

     *

Can be any printable ASCII character (ASCII code 33-126) except
     * ' (single quote), " (double quote), \,
     * /, or @.

     */
    inline const Aws::String& GetMasterUserPassword() const{ return m_masterUserPassword; }

    /**
     *
The new password for the cluster admin user. This change is asynchronously
     * applied as soon as possible. Between the time of the request and the completion
     * of the request, the MasterUserPassword element exists in the
     * PendingModifiedValues element of the operation response.

     *
Operations never return the password, so this operation provides a way
     * to regain access to the admin user account for a cluster if the password is
     * lost.

Default: Uses existing setting.

Constraints:

     *

Must be between 8 and 64 characters in length.

     *
Must contain at least one uppercase letter.

Must contain at
     * least one lowercase letter.

Must contain one number.

     *

Can be any printable ASCII character (ASCII code 33-126) except
     * ' (single quote), " (double quote), \,
     * /, or @.

     */
    inline bool MasterUserPasswordHasBeenSet() const { return m_masterUserPasswordHasBeenSet; }

    /**
     *
The new password for the cluster admin user. This change is asynchronously
     * applied as soon as possible. Between the time of the request and the completion
     * of the request, the MasterUserPassword element exists in the
     * PendingModifiedValues element of the operation response.

     *
Operations never return the password, so this operation provides a way
     * to regain access to the admin user account for a cluster if the password is
     * lost.

Default: Uses existing setting.

Constraints:

     *

Must be between 8 and 64 characters in length.

     *
Must contain at least one uppercase letter.

Must contain at
     * least one lowercase letter.

Must contain one number.

     *

Can be any printable ASCII character (ASCII code 33-126) except
     * ' (single quote), " (double quote), \,
     * /, or @.

     */
    inline void SetMasterUserPassword(const Aws::String& value) { m_masterUserPasswordHasBeenSet = true; m_masterUserPassword = value; }

    /**
     *
The new password for the cluster admin user. This change is asynchronously
     * applied as soon as possible. Between the time of the request and the completion
     * of the request, the MasterUserPassword element exists in the
     * PendingModifiedValues element of the operation response.

     *
Operations never return the password, so this operation provides a way
     * to regain access to the admin user account for a cluster if the password is
     * lost.

Default: Uses existing setting.

Constraints:

     *

Must be between 8 and 64 characters in length.

     *
Must contain at least one uppercase letter.

Must contain at
     * least one lowercase letter.

Must contain one number.

     *

Can be any printable ASCII character (ASCII code 33-126) except
     * ' (single quote), " (double quote), \,
     * /, or @.

     */
    inline void SetMasterUserPassword(Aws::String&& value) { m_masterUserPasswordHasBeenSet = true; m_masterUserPassword = std::move(value); }

    /**
     *
The new password for the cluster admin user. This change is asynchronously
     * applied as soon as possible. Between the time of the request and the completion
     * of the request, the MasterUserPassword element exists in the
     * PendingModifiedValues element of the operation response.

     *
Operations never return the password, so this operation provides a way
     * to regain access to the admin user account for a cluster if the password is
     * lost.

Default: Uses existing setting.

Constraints:

     *

Must be between 8 and 64 characters in length.

     *
Must contain at least one uppercase letter.

Must contain at
     * least one lowercase letter.

Must contain one number.

     *

Can be any printable ASCII character (ASCII code 33-126) except
     * ' (single quote), " (double quote), \,
     * /, or @.

     */
    inline void SetMasterUserPassword(const char* value) { m_masterUserPasswordHasBeenSet = true; m_masterUserPassword.assign(value); }

    /**
     *
The new password for the cluster admin user. This change is asynchronously
     * applied as soon as possible. Between the time of the request and the completion
     * of the request, the MasterUserPassword element exists in the
     * PendingModifiedValues element of the operation response.

     *
Operations never return the password, so this operation provides a way
     * to regain access to the admin user account for a cluster if the password is
     * lost.

Default: Uses existing setting.

Constraints:

     *

Must be between 8 and 64 characters in length.

     *
Must contain at least one uppercase letter.

Must contain at
     * least one lowercase letter.

Must contain one number.

     *

Can be any printable ASCII character (ASCII code 33-126) except
     * ' (single quote), " (double quote), \,
     * /, or @.

     */
    inline ModifyClusterRequest& WithMasterUserPassword(const Aws::String& value) { SetMasterUserPassword(value); return *this;}

    /**
     *
The new password for the cluster admin user. This change is asynchronously
     * applied as soon as possible. Between the time of the request and the completion
     * of the request, the MasterUserPassword element exists in the
     * PendingModifiedValues element of the operation response.

     *
Operations never return the password, so this operation provides a way
     * to regain access to the admin user account for a cluster if the password is
     * lost.

Default: Uses existing setting.

Constraints:

     *

Must be between 8 and 64 characters in length.

     *
Must contain at least one uppercase letter.

Must contain at
     * least one lowercase letter.

Must contain one number.

     *

Can be any printable ASCII character (ASCII code 33-126) except
     * ' (single quote), " (double quote), \,
     * /, or @.

     */
    inline ModifyClusterRequest& WithMasterUserPassword(Aws::String&& value) { SetMasterUserPassword(std::move(value)); return *this;}

    /**
     *
The new password for the cluster admin user. This change is asynchronously
     * applied as soon as possible. Between the time of the request and the completion
     * of the request, the MasterUserPassword element exists in the
     * PendingModifiedValues element of the operation response.

     *
Operations never return the password, so this operation provides a way
     * to regain access to the admin user account for a cluster if the password is
     * lost.

Default: Uses existing setting.

Constraints:

     *

Must be between 8 and 64 characters in length.

     *
Must contain at least one uppercase letter.

Must contain at
     * least one lowercase letter.

Must contain one number.

     *

Can be any printable ASCII character (ASCII code 33-126) except
     * ' (single quote), " (double quote), \,
     * /, or @.

     */
    inline ModifyClusterRequest& WithMasterUserPassword(const char* value) { SetMasterUserPassword(value); return *this;}

    /**
     *
The name of the cluster parameter group to apply to this cluster. This change
     * is applied only after the cluster is rebooted. To reboot a cluster use
     * RebootCluster.

Default: Uses existing setting.

     *
Constraints: The cluster parameter group must be in the same parameter group
     * family that matches the cluster version.

     */
    inline const Aws::String& GetClusterParameterGroupName() const{ return m_clusterParameterGroupName; }

    /**
     *
The name of the cluster parameter group to apply to this cluster. This change
     * is applied only after the cluster is rebooted. To reboot a cluster use
     * RebootCluster.

Default: Uses existing setting.

     *
Constraints: The cluster parameter group must be in the same parameter group
     * family that matches the cluster version.

     */
    inline bool ClusterParameterGroupNameHasBeenSet() const { return m_clusterParameterGroupNameHasBeenSet; }

    /**
     *
The name of the cluster parameter group to apply to this cluster. This change
     * is applied only after the cluster is rebooted. To reboot a cluster use
     * RebootCluster.

Default: Uses existing setting.

     *
Constraints: The cluster parameter group must be in the same parameter group
     * family that matches the cluster version.

     */
    inline void SetClusterParameterGroupName(const Aws::String& value) { m_clusterParameterGroupNameHasBeenSet = true; m_clusterParameterGroupName = value; }

    /**
     *
The name of the cluster parameter group to apply to this cluster. This change
     * is applied only after the cluster is rebooted. To reboot a cluster use
     * RebootCluster.

Default: Uses existing setting.

     *
Constraints: The cluster parameter group must be in the same parameter group
     * family that matches the cluster version.

     */
    inline void SetClusterParameterGroupName(Aws::String&& value) { m_clusterParameterGroupNameHasBeenSet = true; m_clusterParameterGroupName = std::move(value); }

    /**
     *
The name of the cluster parameter group to apply to this cluster. This change
     * is applied only after the cluster is rebooted. To reboot a cluster use
     * RebootCluster.

Default: Uses existing setting.

     *
Constraints: The cluster parameter group must be in the same parameter group
     * family that matches the cluster version.

     */
    inline void SetClusterParameterGroupName(const char* value) { m_clusterParameterGroupNameHasBeenSet = true; m_clusterParameterGroupName.assign(value); }

    /**
     *
The name of the cluster parameter group to apply to this cluster. This change
     * is applied only after the cluster is rebooted. To reboot a cluster use
     * RebootCluster.

Default: Uses existing setting.

     *
Constraints: The cluster parameter group must be in the same parameter group
     * family that matches the cluster version.

     */
    inline ModifyClusterRequest& WithClusterParameterGroupName(const Aws::String& value) { SetClusterParameterGroupName(value); return *this;}

    /**
     *
The name of the cluster parameter group to apply to this cluster. This change
     * is applied only after the cluster is rebooted. To reboot a cluster use
     * RebootCluster.

Default: Uses existing setting.

     *
Constraints: The cluster parameter group must be in the same parameter group
     * family that matches the cluster version.

     */
    inline ModifyClusterRequest& WithClusterParameterGroupName(Aws::String&& value) { SetClusterParameterGroupName(std::move(value)); return *this;}

    /**
     *
The name of the cluster parameter group to apply to this cluster. This change
     * is applied only after the cluster is rebooted. To reboot a cluster use
     * RebootCluster.

Default: Uses existing setting.

     *
Constraints: The cluster parameter group must be in the same parameter group
     * family that matches the cluster version.

     */
    inline ModifyClusterRequest& WithClusterParameterGroupName(const char* value) { SetClusterParameterGroupName(value); return *this;}

    /**
     *
The number of days that automated snapshots are retained. If the value is 0,
     * automated snapshots are disabled. Even if automated snapshots are disabled, you
     * can still create manual snapshots when you want with
     * CreateClusterSnapshot.

If you decrease the automated snapshot
     * retention period from its current value, existing automated snapshots that fall
     * outside of the new retention period will be immediately deleted.

You
     * can't disable automated snapshots for RA3 node types. Set the automated
     * retention period from 1-35 days.

Default: Uses existing setting.

     *
Constraints: Must be a value from 0 to 35.

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

    /**
     *
The number of days that automated snapshots are retained. If the value is 0,
     * automated snapshots are disabled. Even if automated snapshots are disabled, you
     * can still create manual snapshots when you want with
     * CreateClusterSnapshot.

If you decrease the automated snapshot
     * retention period from its current value, existing automated snapshots that fall
     * outside of the new retention period will be immediately deleted.

You
     * can't disable automated snapshots for RA3 node types. Set the automated
     * retention period from 1-35 days.

Default: Uses existing setting.

     *
Constraints: Must be a value from 0 to 35.

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

    /**
     *
The number of days that automated snapshots are retained. If the value is 0,
     * automated snapshots are disabled. Even if automated snapshots are disabled, you
     * can still create manual snapshots when you want with
     * CreateClusterSnapshot.

If you decrease the automated snapshot
     * retention period from its current value, existing automated snapshots that fall
     * outside of the new retention period will be immediately deleted.

You
     * can't disable automated snapshots for RA3 node types. Set the automated
     * retention period from 1-35 days.

Default: Uses existing setting.

     *
Constraints: Must be a value from 0 to 35.

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

    /**
     *
The number of days that automated snapshots are retained. If the value is 0,
     * automated snapshots are disabled. Even if automated snapshots are disabled, you
     * can still create manual snapshots when you want with
     * CreateClusterSnapshot.

If you decrease the automated snapshot
     * retention period from its current value, existing automated snapshots that fall
     * outside of the new retention period will be immediately deleted.

You
     * can't disable automated snapshots for RA3 node types. Set the automated
     * retention period from 1-35 days.

Default: Uses existing setting.

     *
Constraints: Must be a value from 0 to 35.

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

    /**
     *
The default for number of days that a newly created manual snapshot is
     * retained. If the value is -1, the manual snapshot is retained indefinitely. This
     * value doesn't retroactively change the retention periods of existing manual
     * snapshots.

The value must be either -1 or an integer between 1 and
     * 3,653.

The default value is -1.

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

    /**
     *
The default for number of days that a newly created manual snapshot is
     * retained. If the value is -1, the manual snapshot is retained indefinitely. This
     * value doesn't retroactively change the retention periods of existing manual
     * snapshots.

The value must be either -1 or an integer between 1 and
     * 3,653.

The default value is -1.

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

    /**
     *
The default for number of days that a newly created manual snapshot is
     * retained. If the value is -1, the manual snapshot is retained indefinitely. This
     * value doesn't retroactively change the retention periods of existing manual
     * snapshots.

The value must be either -1 or an integer between 1 and
     * 3,653.

The default value is -1.

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

    /**
     *
The default for number of days that a newly created manual snapshot is
     * retained. If the value is -1, the manual snapshot is retained indefinitely. This
     * value doesn't retroactively change the retention periods of existing manual
     * snapshots.

The value must be either -1 or an integer between 1 and
     * 3,653.

The default value is -1.

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

    /**
     *
The weekly time range (in UTC) during which system maintenance can occur, if
     * necessary. If system maintenance is necessary during the window, it may result
     * in an outage.

This maintenance window change is made immediately. If the
     * new maintenance window indicates the current time, there must be at least 120
     * minutes between the current time and end of the window in order to ensure that
     * pending changes are applied.

Default: Uses existing setting.

     *
Format: ddd:hh24:mi-ddd:hh24:mi, for example
     * wed:07:30-wed:08:00.

Valid Days: Mon | Tue | Wed | Thu | Fri
     * | Sat | Sun

Constraints: Must be at least 30 minutes.

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

    /**
     *
The weekly time range (in UTC) during which system maintenance can occur, if
     * necessary. If system maintenance is necessary during the window, it may result
     * in an outage.

This maintenance window change is made immediately. If the
     * new maintenance window indicates the current time, there must be at least 120
     * minutes between the current time and end of the window in order to ensure that
     * pending changes are applied.

Default: Uses existing setting.

     *
Format: ddd:hh24:mi-ddd:hh24:mi, for example
     * wed:07:30-wed:08:00.

Valid Days: Mon | Tue | Wed | Thu | Fri
     * | Sat | Sun

Constraints: Must be at least 30 minutes.

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

    /**
     *
The weekly time range (in UTC) during which system maintenance can occur, if
     * necessary. If system maintenance is necessary during the window, it may result
     * in an outage.

This maintenance window change is made immediately. If the
     * new maintenance window indicates the current time, there must be at least 120
     * minutes between the current time and end of the window in order to ensure that
     * pending changes are applied.

Default: Uses existing setting.

     *
Format: ddd:hh24:mi-ddd:hh24:mi, for example
     * wed:07:30-wed:08:00.

Valid Days: Mon | Tue | Wed | Thu | Fri
     * | Sat | Sun

Constraints: Must be at least 30 minutes.

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

    /**
     *
The weekly time range (in UTC) during which system maintenance can occur, if
     * necessary. If system maintenance is necessary during the window, it may result
     * in an outage.

This maintenance window change is made immediately. If the
     * new maintenance window indicates the current time, there must be at least 120
     * minutes between the current time and end of the window in order to ensure that
     * pending changes are applied.

Default: Uses existing setting.

     *
Format: ddd:hh24:mi-ddd:hh24:mi, for example
     * wed:07:30-wed:08:00.

Valid Days: Mon | Tue | Wed | Thu | Fri
     * | Sat | Sun

Constraints: Must be at least 30 minutes.

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

    /**
     *
The weekly time range (in UTC) during which system maintenance can occur, if
     * necessary. If system maintenance is necessary during the window, it may result
     * in an outage.

This maintenance window change is made immediately. If the
     * new maintenance window indicates the current time, there must be at least 120
     * minutes between the current time and end of the window in order to ensure that
     * pending changes are applied.

Default: Uses existing setting.

     *
Format: ddd:hh24:mi-ddd:hh24:mi, for example
     * wed:07:30-wed:08:00.

Valid Days: Mon | Tue | Wed | Thu | Fri
     * | Sat | Sun

Constraints: Must be at least 30 minutes.

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

    /**
     *
The weekly time range (in UTC) during which system maintenance can occur, if
     * necessary. If system maintenance is necessary during the window, it may result
     * in an outage.

This maintenance window change is made immediately. If the
     * new maintenance window indicates the current time, there must be at least 120
     * minutes between the current time and end of the window in order to ensure that
     * pending changes are applied.

Default: Uses existing setting.

     *
Format: ddd:hh24:mi-ddd:hh24:mi, for example
     * wed:07:30-wed:08:00.

Valid Days: Mon | Tue | Wed | Thu | Fri
     * | Sat | Sun

Constraints: Must be at least 30 minutes.

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

    /**
     *
The weekly time range (in UTC) during which system maintenance can occur, if
     * necessary. If system maintenance is necessary during the window, it may result
     * in an outage.

This maintenance window change is made immediately. If the
     * new maintenance window indicates the current time, there must be at least 120
     * minutes between the current time and end of the window in order to ensure that
     * pending changes are applied.

Default: Uses existing setting.

     *
Format: ddd:hh24:mi-ddd:hh24:mi, for example
     * wed:07:30-wed:08:00.

Valid Days: Mon | Tue | Wed | Thu | Fri
     * | Sat | Sun

Constraints: Must be at least 30 minutes.

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

    /**
     *
The weekly time range (in UTC) during which system maintenance can occur, if
     * necessary. If system maintenance is necessary during the window, it may result
     * in an outage.

This maintenance window change is made immediately. If the
     * new maintenance window indicates the current time, there must be at least 120
     * minutes between the current time and end of the window in order to ensure that
     * pending changes are applied.

Default: Uses existing setting.

     *
Format: ddd:hh24:mi-ddd:hh24:mi, for example
     * wed:07:30-wed:08:00.

Valid Days: Mon | Tue | Wed | Thu | Fri
     * | Sat | Sun

Constraints: Must be at least 30 minutes.

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

    /**
     *
The new version number of the Amazon Redshift engine to upgrade to.

     *
For major version upgrades, if a non-default cluster parameter group is
     * currently in use, a new cluster parameter group in the cluster parameter group
     * family for the new version must be specified. The new cluster parameter group
     * can be the default for that cluster parameter group family. For more information
     * about parameters and parameter groups, go to Amazon
     * Redshift Parameter Groups in the Amazon Redshift Cluster Management
     * Guide.

Example: 1.0

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

    /**
     *
The new version number of the Amazon Redshift engine to upgrade to.

     *
For major version upgrades, if a non-default cluster parameter group is
     * currently in use, a new cluster parameter group in the cluster parameter group
     * family for the new version must be specified. The new cluster parameter group
     * can be the default for that cluster parameter group family. For more information
     * about parameters and parameter groups, go to Amazon
     * Redshift Parameter Groups in the Amazon Redshift Cluster Management
     * Guide.

Example: 1.0

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

    /**
     *
The new version number of the Amazon Redshift engine to upgrade to.

     *
For major version upgrades, if a non-default cluster parameter group is
     * currently in use, a new cluster parameter group in the cluster parameter group
     * family for the new version must be specified. The new cluster parameter group
     * can be the default for that cluster parameter group family. For more information
     * about parameters and parameter groups, go to Amazon
     * Redshift Parameter Groups in the Amazon Redshift Cluster Management
     * Guide.

Example: 1.0

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

    /**
     *
The new version number of the Amazon Redshift engine to upgrade to.

     *
For major version upgrades, if a non-default cluster parameter group is
     * currently in use, a new cluster parameter group in the cluster parameter group
     * family for the new version must be specified. The new cluster parameter group
     * can be the default for that cluster parameter group family. For more information
     * about parameters and parameter groups, go to Amazon
     * Redshift Parameter Groups in the Amazon Redshift Cluster Management
     * Guide.

Example: 1.0

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

    /**
     *
The new version number of the Amazon Redshift engine to upgrade to.

     *
For major version upgrades, if a non-default cluster parameter group is
     * currently in use, a new cluster parameter group in the cluster parameter group
     * family for the new version must be specified. The new cluster parameter group
     * can be the default for that cluster parameter group family. For more information
     * about parameters and parameter groups, go to Amazon
     * Redshift Parameter Groups in the Amazon Redshift Cluster Management
     * Guide.

Example: 1.0

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

    /**
     *
The new version number of the Amazon Redshift engine to upgrade to.

     *
For major version upgrades, if a non-default cluster parameter group is
     * currently in use, a new cluster parameter group in the cluster parameter group
     * family for the new version must be specified. The new cluster parameter group
     * can be the default for that cluster parameter group family. For more information
     * about parameters and parameter groups, go to Amazon
     * Redshift Parameter Groups in the Amazon Redshift Cluster Management
     * Guide.

Example: 1.0

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

    /**
     *
The new version number of the Amazon Redshift engine to upgrade to.

     *
For major version upgrades, if a non-default cluster parameter group is
     * currently in use, a new cluster parameter group in the cluster parameter group
     * family for the new version must be specified. The new cluster parameter group
     * can be the default for that cluster parameter group family. For more information
     * about parameters and parameter groups, go to Amazon
     * Redshift Parameter Groups in the Amazon Redshift Cluster Management
     * Guide.

Example: 1.0

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

    /**
     *
The new version number of the Amazon Redshift engine to upgrade to.

     *
For major version upgrades, if a non-default cluster parameter group is
     * currently in use, a new cluster parameter group in the cluster parameter group
     * family for the new version must be specified. The new cluster parameter group
     * can be the default for that cluster parameter group family. For more information
     * about parameters and parameter groups, go to Amazon
     * Redshift Parameter Groups in the Amazon Redshift Cluster Management
     * Guide.

Example: 1.0

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

    /**
     *
If true, major version upgrades will be applied automatically to
     * the cluster during the maintenance window.

Default: false
     *

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

    /**
     *
If true, major version upgrades will be applied automatically to
     * the cluster during the maintenance window.

Default: false
     *

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

    /**
     *
If true, major version upgrades will be applied automatically to
     * the cluster during the maintenance window.

Default: false
     *

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

    /**
     *
If true, major version upgrades will be applied automatically to
     * the cluster during the maintenance window.

Default: false
     *

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

    /**
     *
Specifies the name of the HSM client certificate the Amazon Redshift cluster
     * uses to retrieve the data encryption keys stored in an HSM.

     */
    inline const Aws::String& GetHsmClientCertificateIdentifier() const{ return m_hsmClientCertificateIdentifier; }

    /**
     *
Specifies the name of the HSM client certificate the Amazon Redshift cluster
     * uses to retrieve the data encryption keys stored in an HSM.

     */
    inline bool HsmClientCertificateIdentifierHasBeenSet() const { return m_hsmClientCertificateIdentifierHasBeenSet; }

    /**
     *
Specifies the name of the HSM client certificate the Amazon Redshift cluster
     * uses to retrieve the data encryption keys stored in an HSM.

     */
    inline void SetHsmClientCertificateIdentifier(const Aws::String& value) { m_hsmClientCertificateIdentifierHasBeenSet = true; m_hsmClientCertificateIdentifier = value; }

    /**
     *
Specifies the name of the HSM client certificate the Amazon Redshift cluster
     * uses to retrieve the data encryption keys stored in an HSM.

     */
    inline void SetHsmClientCertificateIdentifier(Aws::String&& value) { m_hsmClientCertificateIdentifierHasBeenSet = true; m_hsmClientCertificateIdentifier = std::move(value); }

    /**
     *
Specifies the name of the HSM client certificate the Amazon Redshift cluster
     * uses to retrieve the data encryption keys stored in an HSM.

     */
    inline void SetHsmClientCertificateIdentifier(const char* value) { m_hsmClientCertificateIdentifierHasBeenSet = true; m_hsmClientCertificateIdentifier.assign(value); }

    /**
     *
Specifies the name of the HSM client certificate the Amazon Redshift cluster
     * uses to retrieve the data encryption keys stored in an HSM.

     */
    inline ModifyClusterRequest& WithHsmClientCertificateIdentifier(const Aws::String& value) { SetHsmClientCertificateIdentifier(value); return *this;}

    /**
     *
Specifies the name of the HSM client certificate the Amazon Redshift cluster
     * uses to retrieve the data encryption keys stored in an HSM.

     */
    inline ModifyClusterRequest& WithHsmClientCertificateIdentifier(Aws::String&& value) { SetHsmClientCertificateIdentifier(std::move(value)); return *this;}

    /**
     *
Specifies the name of the HSM client certificate the Amazon Redshift cluster
     * uses to retrieve the data encryption keys stored in an HSM.

     */
    inline ModifyClusterRequest& WithHsmClientCertificateIdentifier(const char* value) { SetHsmClientCertificateIdentifier(value); return *this;}

    /**
     *
Specifies the name of the HSM configuration that contains the information the
     * Amazon Redshift cluster can use to retrieve and store keys in an HSM.

     */
    inline const Aws::String& GetHsmConfigurationIdentifier() const{ return m_hsmConfigurationIdentifier; }

    /**
     *
Specifies the name of the HSM configuration that contains the information the
     * Amazon Redshift cluster can use to retrieve and store keys in an HSM.

     */
    inline bool HsmConfigurationIdentifierHasBeenSet() const { return m_hsmConfigurationIdentifierHasBeenSet; }

    /**
     *
Specifies the name of the HSM configuration that contains the information the
     * Amazon Redshift cluster can use to retrieve and store keys in an HSM.

     */
    inline void SetHsmConfigurationIdentifier(const Aws::String& value) { m_hsmConfigurationIdentifierHasBeenSet = true; m_hsmConfigurationIdentifier = value; }

    /**
     *
Specifies the name of the HSM configuration that contains the information the
     * Amazon Redshift cluster can use to retrieve and store keys in an HSM.

     */
    inline void SetHsmConfigurationIdentifier(Aws::String&& value) { m_hsmConfigurationIdentifierHasBeenSet = true; m_hsmConfigurationIdentifier = std::move(value); }

    /**
     *
Specifies the name of the HSM configuration that contains the information the
     * Amazon Redshift cluster can use to retrieve and store keys in an HSM.

     */
    inline void SetHsmConfigurationIdentifier(const char* value) { m_hsmConfigurationIdentifierHasBeenSet = true; m_hsmConfigurationIdentifier.assign(value); }

    /**
     *
Specifies the name of the HSM configuration that contains the information the
     * Amazon Redshift cluster can use to retrieve and store keys in an HSM.

     */
    inline ModifyClusterRequest& WithHsmConfigurationIdentifier(const Aws::String& value) { SetHsmConfigurationIdentifier(value); return *this;}

    /**
     *
Specifies the name of the HSM configuration that contains the information the
     * Amazon Redshift cluster can use to retrieve and store keys in an HSM.

     */
    inline ModifyClusterRequest& WithHsmConfigurationIdentifier(Aws::String&& value) { SetHsmConfigurationIdentifier(std::move(value)); return *this;}

    /**
     *
Specifies the name of the HSM configuration that contains the information the
     * Amazon Redshift cluster can use to retrieve and store keys in an HSM.

     */
    inline ModifyClusterRequest& WithHsmConfigurationIdentifier(const char* value) { SetHsmConfigurationIdentifier(value); return *this;}

    /**
     *
The new identifier for the cluster.

Constraints:

Must
     * contain from 1 to 63 alphanumeric characters or hyphens.

     *
Alphabetic characters must be lowercase.

First character
     * must be a letter.

Cannot end with a hyphen or contain two
     * consecutive hyphens.

Must be unique for all clusters within an
     * Amazon Web Services account.

Example:
     * examplecluster

     */
    inline const Aws::String& GetNewClusterIdentifier() const{ return m_newClusterIdentifier; }

    /**
     *
The new identifier for the cluster.

Constraints:

Must
     * contain from 1 to 63 alphanumeric characters or hyphens.

     *
Alphabetic characters must be lowercase.

First character
     * must be a letter.

Cannot end with a hyphen or contain two
     * consecutive hyphens.

Must be unique for all clusters within an
     * Amazon Web Services account.

Example:
     * examplecluster

     */
    inline bool NewClusterIdentifierHasBeenSet() const { return m_newClusterIdentifierHasBeenSet; }

    /**
     *
The new identifier for the cluster.

Constraints:

Must
     * contain from 1 to 63 alphanumeric characters or hyphens.

     *
Alphabetic characters must be lowercase.

First character
     * must be a letter.

Cannot end with a hyphen or contain two
     * consecutive hyphens.

Must be unique for all clusters within an
     * Amazon Web Services account.

Example:
     * examplecluster

     */
    inline void SetNewClusterIdentifier(const Aws::String& value) { m_newClusterIdentifierHasBeenSet = true; m_newClusterIdentifier = value; }

    /**
     *
The new identifier for the cluster.

Constraints:

Must
     * contain from 1 to 63 alphanumeric characters or hyphens.

     *
Alphabetic characters must be lowercase.

First character
     * must be a letter.

Cannot end with a hyphen or contain two
     * consecutive hyphens.

Must be unique for all clusters within an
     * Amazon Web Services account.

Example:
     * examplecluster

     */
    inline void SetNewClusterIdentifier(Aws::String&& value) { m_newClusterIdentifierHasBeenSet = true; m_newClusterIdentifier = std::move(value); }

    /**
     *
The new identifier for the cluster.

Constraints:

Must
     * contain from 1 to 63 alphanumeric characters or hyphens.

     *
Alphabetic characters must be lowercase.

First character
     * must be a letter.

Cannot end with a hyphen or contain two
     * consecutive hyphens.

Must be unique for all clusters within an
     * Amazon Web Services account.

Example:
     * examplecluster

     */
    inline void SetNewClusterIdentifier(const char* value) { m_newClusterIdentifierHasBeenSet = true; m_newClusterIdentifier.assign(value); }

    /**
     *
The new identifier for the cluster.

Constraints:

Must
     * contain from 1 to 63 alphanumeric characters or hyphens.

     *
Alphabetic characters must be lowercase.

First character
     * must be a letter.

Cannot end with a hyphen or contain two
     * consecutive hyphens.

Must be unique for all clusters within an
     * Amazon Web Services account.

Example:
     * examplecluster

     */
    inline ModifyClusterRequest& WithNewClusterIdentifier(const Aws::String& value) { SetNewClusterIdentifier(value); return *this;}

    /**
     *
The new identifier for the cluster.

Constraints:

Must
     * contain from 1 to 63 alphanumeric characters or hyphens.

     *
Alphabetic characters must be lowercase.

First character
     * must be a letter.

Cannot end with a hyphen or contain two
     * consecutive hyphens.

Must be unique for all clusters within an
     * Amazon Web Services account.

Example:
     * examplecluster

     */
    inline ModifyClusterRequest& WithNewClusterIdentifier(Aws::String&& value) { SetNewClusterIdentifier(std::move(value)); return *this;}

    /**
     *
The new identifier for the cluster.

Constraints:

Must
     * contain from 1 to 63 alphanumeric characters or hyphens.

     *
Alphabetic characters must be lowercase.

First character
     * must be a letter.

Cannot end with a hyphen or contain two
     * consecutive hyphens.

Must be unique for all clusters within an
     * Amazon Web Services account.

Example:
     * examplecluster

     */
    inline ModifyClusterRequest& WithNewClusterIdentifier(const char* value) { SetNewClusterIdentifier(value); return *this;}

    /**
     *
If true, the cluster can be accessed from a public network. Only
     * clusters in VPCs can be set to be publicly available.

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

    /**
     *
If true, the cluster can be accessed from a public network. Only
     * clusters in VPCs can be set to be publicly available.

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

    /**
     *
If true, the cluster can be accessed from a public network. Only
     * clusters in VPCs can be set to be publicly available.

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

    /**
     *
If true, the cluster can be accessed from a public network. Only
     * clusters in VPCs can be set to be publicly available.

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

    /**
     *
The Elastic IP (EIP) address for the cluster.

Constraints: The cluster
     * must be provisioned in EC2-VPC and publicly-accessible through an Internet
     * gateway. For more information about provisioning clusters in EC2-VPC, go to Supported
     * Platforms to Launch Your Cluster in the Amazon Redshift Cluster Management
     * Guide.

     */
    inline const Aws::String& GetElasticIp() const{ return m_elasticIp; }

    /**
     *
The Elastic IP (EIP) address for the cluster.

Constraints: The cluster
     * must be provisioned in EC2-VPC and publicly-accessible through an Internet
     * gateway. For more information about provisioning clusters in EC2-VPC, go to Supported
     * Platforms to Launch Your Cluster in the Amazon Redshift Cluster Management
     * Guide.

     */
    inline bool ElasticIpHasBeenSet() const { return m_elasticIpHasBeenSet; }

    /**
     *
The Elastic IP (EIP) address for the cluster.

Constraints: The cluster
     * must be provisioned in EC2-VPC and publicly-accessible through an Internet
     * gateway. For more information about provisioning clusters in EC2-VPC, go to Supported
     * Platforms to Launch Your Cluster in the Amazon Redshift Cluster Management
     * Guide.

     */
    inline void SetElasticIp(const Aws::String& value) { m_elasticIpHasBeenSet = true; m_elasticIp = value; }

    /**
     *
The Elastic IP (EIP) address for the cluster.

Constraints: The cluster
     * must be provisioned in EC2-VPC and publicly-accessible through an Internet
     * gateway. For more information about provisioning clusters in EC2-VPC, go to Supported
     * Platforms to Launch Your Cluster in the Amazon Redshift Cluster Management
     * Guide.

     */
    inline void SetElasticIp(Aws::String&& value) { m_elasticIpHasBeenSet = true; m_elasticIp = std::move(value); }

    /**
     *
The Elastic IP (EIP) address for the cluster.

Constraints: The cluster
     * must be provisioned in EC2-VPC and publicly-accessible through an Internet
     * gateway. For more information about provisioning clusters in EC2-VPC, go to Supported
     * Platforms to Launch Your Cluster in the Amazon Redshift Cluster Management
     * Guide.

     */
    inline void SetElasticIp(const char* value) { m_elasticIpHasBeenSet = true; m_elasticIp.assign(value); }

    /**
     *
The Elastic IP (EIP) address for the cluster.

Constraints: The cluster
     * must be provisioned in EC2-VPC and publicly-accessible through an Internet
     * gateway. For more information about provisioning clusters in EC2-VPC, go to Supported
     * Platforms to Launch Your Cluster in the Amazon Redshift Cluster Management
     * Guide.

     */
    inline ModifyClusterRequest& WithElasticIp(const Aws::String& value) { SetElasticIp(value); return *this;}

    /**
     *
The Elastic IP (EIP) address for the cluster.

Constraints: The cluster
     * must be provisioned in EC2-VPC and publicly-accessible through an Internet
     * gateway. For more information about provisioning clusters in EC2-VPC, go to Supported
     * Platforms to Launch Your Cluster in the Amazon Redshift Cluster Management
     * Guide.

     */
    inline ModifyClusterRequest& WithElasticIp(Aws::String&& value) { SetElasticIp(std::move(value)); return *this;}

    /**
     *
The Elastic IP (EIP) address for the cluster.

Constraints: The cluster
     * must be provisioned in EC2-VPC and publicly-accessible through an Internet
     * gateway. For more information about provisioning clusters in EC2-VPC, go to Supported
     * Platforms to Launch Your Cluster in the Amazon Redshift Cluster Management
     * Guide.

     */
    inline ModifyClusterRequest& WithElasticIp(const char* value) { SetElasticIp(value); return *this;}

    /**
     *
An option that specifies whether to create the cluster with enhanced VPC
     * routing enabled. To create a cluster that uses enhanced VPC routing, the cluster
     * must be in a VPC. For more information, see Enhanced
     * VPC Routing in the Amazon Redshift Cluster Management Guide.

If this
     * option is true, enhanced VPC routing is enabled.

Default:
     * false

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

    /**
     *
An option that specifies whether to create the cluster with enhanced VPC
     * routing enabled. To create a cluster that uses enhanced VPC routing, the cluster
     * must be in a VPC. For more information, see Enhanced
     * VPC Routing in the Amazon Redshift Cluster Management Guide.

If this
     * option is true, enhanced VPC routing is enabled.

Default:
     * false

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

    /**
     *
An option that specifies whether to create the cluster with enhanced VPC
     * routing enabled. To create a cluster that uses enhanced VPC routing, the cluster
     * must be in a VPC. For more information, see Enhanced
     * VPC Routing in the Amazon Redshift Cluster Management Guide.

If this
     * option is true, enhanced VPC routing is enabled.

Default:
     * false

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

    /**
     *
An option that specifies whether to create the cluster with enhanced VPC
     * routing enabled. To create a cluster that uses enhanced VPC routing, the cluster
     * must be in a VPC. For more information, see Enhanced
     * VPC Routing in the Amazon Redshift Cluster Management Guide.

If this
     * option is true, enhanced VPC routing is enabled.

Default:
     * false

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

    /**
     *
The name for the maintenance track that you want to assign for the cluster.
     * This name change is asynchronous. The new track name stays in the
     * PendingModifiedValues for the cluster until the next maintenance
     * window. When the maintenance track changes, the cluster is switched to the
     * latest cluster release available for the maintenance track. At this point, the
     * maintenance track name is applied.

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

    /**
     *
The name for the maintenance track that you want to assign for the cluster.
     * This name change is asynchronous. The new track name stays in the
     * PendingModifiedValues for the cluster until the next maintenance
     * window. When the maintenance track changes, the cluster is switched to the
     * latest cluster release available for the maintenance track. At this point, the
     * maintenance track name is applied.

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

    /**
     *
The name for the maintenance track that you want to assign for the cluster.
     * This name change is asynchronous. The new track name stays in the
     * PendingModifiedValues for the cluster until the next maintenance
     * window. When the maintenance track changes, the cluster is switched to the
     * latest cluster release available for the maintenance track. At this point, the
     * maintenance track name is applied.

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

    /**
     *
The name for the maintenance track that you want to assign for the cluster.
     * This name change is asynchronous. The new track name stays in the
     * PendingModifiedValues for the cluster until the next maintenance
     * window. When the maintenance track changes, the cluster is switched to the
     * latest cluster release available for the maintenance track. At this point, the
     * maintenance track name is applied.

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

    /**
     *
The name for the maintenance track that you want to assign for the cluster.
     * This name change is asynchronous. The new track name stays in the
     * PendingModifiedValues for the cluster until the next maintenance
     * window. When the maintenance track changes, the cluster is switched to the
     * latest cluster release available for the maintenance track. At this point, the
     * maintenance track name is applied.

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

    /**
     *
The name for the maintenance track that you want to assign for the cluster.
     * This name change is asynchronous. The new track name stays in the
     * PendingModifiedValues for the cluster until the next maintenance
     * window. When the maintenance track changes, the cluster is switched to the
     * latest cluster release available for the maintenance track. At this point, the
     * maintenance track name is applied.

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

    /**
     *
The name for the maintenance track that you want to assign for the cluster.
     * This name change is asynchronous. The new track name stays in the
     * PendingModifiedValues for the cluster until the next maintenance
     * window. When the maintenance track changes, the cluster is switched to the
     * latest cluster release available for the maintenance track. At this point, the
     * maintenance track name is applied.

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

    /**
     *
The name for the maintenance track that you want to assign for the cluster.
     * This name change is asynchronous. The new track name stays in the
     * PendingModifiedValues for the cluster until the next maintenance
     * window. When the maintenance track changes, the cluster is switched to the
     * latest cluster release available for the maintenance track. At this point, the
     * maintenance track name is applied.

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

    /**
     *
Indicates whether the cluster is encrypted. If the value is encrypted (true)
     * and you provide a value for the KmsKeyId parameter, we encrypt the
     * cluster with the provided KmsKeyId. If you don't provide a
     * KmsKeyId, we encrypt with the default key.

If the value is
     * not encrypted (false), then the cluster is decrypted.

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

    /**
     *
Indicates whether the cluster is encrypted. If the value is encrypted (true)
     * and you provide a value for the KmsKeyId parameter, we encrypt the
     * cluster with the provided KmsKeyId. If you don't provide a
     * KmsKeyId, we encrypt with the default key.

If the value is
     * not encrypted (false), then the cluster is decrypted.

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

    /**
     *
Indicates whether the cluster is encrypted. If the value is encrypted (true)
     * and you provide a value for the KmsKeyId parameter, we encrypt the
     * cluster with the provided KmsKeyId. If you don't provide a
     * KmsKeyId, we encrypt with the default key.

If the value is
     * not encrypted (false), then the cluster is decrypted.

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

    /**
     *
Indicates whether the cluster is encrypted. If the value is encrypted (true)
     * and you provide a value for the KmsKeyId parameter, we encrypt the
     * cluster with the provided KmsKeyId. If you don't provide a
     * KmsKeyId, we encrypt with the default key.

If the value is
     * not encrypted (false), then the cluster is decrypted.

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

    /**
     *
The Key Management Service (KMS) key ID of the encryption key that you want
     * to use to encrypt data in the cluster.

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

    /**
     *
The Key Management Service (KMS) key ID of the encryption key that you want
     * to use to encrypt data in the cluster.

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

    /**
     *
The Key Management Service (KMS) key ID of the encryption key that you want
     * to use to encrypt data in the cluster.

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

    /**
     *
The Key Management Service (KMS) key ID of the encryption key that you want
     * to use to encrypt data in the cluster.

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

    /**
     *
The Key Management Service (KMS) key ID of the encryption key that you want
     * to use to encrypt data in the cluster.

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

    /**
     *
The Key Management Service (KMS) key ID of the encryption key that you want
     * to use to encrypt data in the cluster.

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

    /**
     *
The Key Management Service (KMS) key ID of the encryption key that you want
     * to use to encrypt data in the cluster.

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

    /**
     *
The Key Management Service (KMS) key ID of the encryption key that you want
     * to use to encrypt data in the cluster.

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

    /**
     *
The option to enable relocation for an Amazon Redshift cluster between
     * Availability Zones after the cluster modification is complete.

     */
    inline bool GetAvailabilityZoneRelocation() const{ return m_availabilityZoneRelocation; }

    /**
     *
The option to enable relocation for an Amazon Redshift cluster between
     * Availability Zones after the cluster modification is complete.

     */
    inline bool AvailabilityZoneRelocationHasBeenSet() const { return m_availabilityZoneRelocationHasBeenSet; }

    /**
     *
The option to enable relocation for an Amazon Redshift cluster between
     * Availability Zones after the cluster modification is complete.

     */
    inline void SetAvailabilityZoneRelocation(bool value) { m_availabilityZoneRelocationHasBeenSet = true; m_availabilityZoneRelocation = value; }

    /**
     *
The option to enable relocation for an Amazon Redshift cluster between
     * Availability Zones after the cluster modification is complete.

     */
    inline ModifyClusterRequest& WithAvailabilityZoneRelocation(bool value) { SetAvailabilityZoneRelocation(value); return *this;}

    /**
     *
The option to initiate relocation for an Amazon Redshift cluster to the
     * target Availability Zone.

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

    /**
     *
The option to initiate relocation for an Amazon Redshift cluster to the
     * target Availability Zone.

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

    /**
     *
The option to initiate relocation for an Amazon Redshift cluster to the
     * target Availability Zone.

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

    /**
     *
The option to initiate relocation for an Amazon Redshift cluster to the
     * target Availability Zone.

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

    /**
     *
The option to initiate relocation for an Amazon Redshift cluster to the
     * target Availability Zone.

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

    /**
     *
The option to initiate relocation for an Amazon Redshift cluster to the
     * target Availability Zone.

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

    /**
     *
The option to initiate relocation for an Amazon Redshift cluster to the
     * target Availability Zone.

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

    /**
     *
The option to initiate relocation for an Amazon Redshift cluster to the
     * target Availability Zone.

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

    /**
     *
The option to change the port of an Amazon Redshift cluster.

     */
    inline int GetPort() const{ return m_port; }

    /**
     *
The option to change the port of an Amazon Redshift cluster.

     */
    inline bool PortHasBeenSet() const { return m_portHasBeenSet; }

    /**
     *
The option to change the port of an Amazon Redshift cluster.

     */
    inline void SetPort(int value) { m_portHasBeenSet = true; m_port = value; }

    /**
     *
The option to change the port of an Amazon Redshift cluster.

     */
    inline ModifyClusterRequest& WithPort(int value) { SetPort(value); return *this;}

  private:

    Aws::String m_clusterIdentifier;
    bool m_clusterIdentifierHasBeenSet = false;

    Aws::String m_clusterType;
    bool m_clusterTypeHasBeenSet = false;

    Aws::String m_nodeType;
    bool m_nodeTypeHasBeenSet = false;

    int m_numberOfNodes;
    bool m_numberOfNodesHasBeenSet = false;

    Aws::Vector<Aws::String> m_clusterSecurityGroups;
    bool m_clusterSecurityGroupsHasBeenSet = false;

    Aws::Vector<Aws::String> m_vpcSecurityGroupIds;
    bool m_vpcSecurityGroupIdsHasBeenSet = false;

    Aws::String m_masterUserPassword;
    bool m_masterUserPasswordHasBeenSet = false;

    Aws::String m_clusterParameterGroupName;
    bool m_clusterParameterGroupNameHasBeenSet = false;

    int m_automatedSnapshotRetentionPeriod;
    bool m_automatedSnapshotRetentionPeriodHasBeenSet = false;

    int m_manualSnapshotRetentionPeriod;
    bool m_manualSnapshotRetentionPeriodHasBeenSet = false;

    Aws::String m_preferredMaintenanceWindow;
    bool m_preferredMaintenanceWindowHasBeenSet = false;

    Aws::String m_clusterVersion;
    bool m_clusterVersionHasBeenSet = false;

    bool m_allowVersionUpgrade;
    bool m_allowVersionUpgradeHasBeenSet = false;

    Aws::String m_hsmClientCertificateIdentifier;
    bool m_hsmClientCertificateIdentifierHasBeenSet = false;

    Aws::String m_hsmConfigurationIdentifier;
    bool m_hsmConfigurationIdentifierHasBeenSet = false;

    Aws::String m_newClusterIdentifier;
    bool m_newClusterIdentifierHasBeenSet = false;

    bool m_publiclyAccessible;
    bool m_publiclyAccessibleHasBeenSet = false;

    Aws::String m_elasticIp;
    bool m_elasticIpHasBeenSet = false;

    bool m_enhancedVpcRouting;
    bool m_enhancedVpcRoutingHasBeenSet = false;

    Aws::String m_maintenanceTrackName;
    bool m_maintenanceTrackNameHasBeenSet = false;

    bool m_encrypted;
    bool m_encryptedHasBeenSet = false;

    Aws::String m_kmsKeyId;
    bool m_kmsKeyIdHasBeenSet = false;

    bool m_availabilityZoneRelocation;
    bool m_availabilityZoneRelocationHasBeenSet = false;

    Aws::String m_availabilityZone;
    bool m_availabilityZoneHasBeenSet = false;

    int m_port;
    bool m_portHasBeenSet = false;
  };

} // namespace Model
} // namespace Redshift
} // namespace Aws

redpajama_set_name: RedPajamaGithub


text:
Helped Peru triumph at ICSID again
People in Who's Who Legal
Pending cases as counsel
Treaty cases
Current arbitrator appointments
68* (of which 23 are as sole or chair)
Lawyers sitting as arbitrator
*Excludes sports cases
In the 1980s and 1990s, Baker McKenzie acted for US companies in a large number of claims against Iran at the Iran–United States Claims Tribunal in The Hague, becoming one of the first US law firms to acquire international arbitration expertise in the days before NAFTA and BIT claims. It went on to advise more than a dozen claimants against Iraq at the United Nations Compensation Commission after the first Gulf War. Since then, the firm has developed a thriving investment treaty arbitration practice alongside its commercial arbitration work.
Increasingly the firm is turning its attention to Asia. Partner Leng Sun Chan SC in Singapore took over as global head of the international arbitration practice in 2015, replacing Grant Hanessian in New York and Guenter Pickrahn in Frankfurt, who had shared the role for six years.
Hanessian remains head of the North America arbitration practice, and is alternate US member of the ICC Court. Various partners in other offices play an active role in the arbitration community. CIS disputes head Vladimir Khvalei in Moscow is a vice president of the ICC Court, chair of the Russian Arbitration Association, and former vice chair of the IBA arbitration committee. Habib Al Mulla in the UAE is vice chairman of the board of the Dubai International Arbitration Centre.
Few practices have the same global reach as Baker McKenzie. The firm says it has around 200 lawyers working on international arbitration in more than 50 jurisdictions – though the number spending more than half their time in the field is closer to 70. Collectively, the group is fluent in more than 20 languages, including Haitian, Creole, Kazakh and Vietnamese.
Alongside the traditional centres, the arbitration practice has acquired outposts in Almaty, Caracas, Dubai, Ho Chi Minh City, Istanbul, Johannesburg, Kuala Lumpur, Lima, Manila and Mexico City, and it is often the first port of call for clients with cross-border disputes in emerging jurisdictions. The firm's Latin American network is particularly impressive, and appears to be bringing in more investment treaty work.
Who uses it?
Air Liquide, Bombardier, Czech bank CSOB, Dow Chemical, FedEx, GlaxoSmithKline, Hyundai, Lukoil, KPMG, Samsung, Siemens, Toshiba and Verizon have all used the firm. More recent clients include the British Olympic Association, FC Barcelona and Texan drilling contractor Weatherford International. In addition, Papua New Guinea and state-controlled entities such as Mexico's Pemex and Brazil's Petrobras have turned to the firm for commercial matters.
At ICSID, the firm's clients on the investor side include mining group Anglo American and Dutch coffee investor Longreef in claims against Venezuela; Kazakh private equity group Visor Capital in a recently settled claim against Kyrgyzstan; Turkish energy company Karkey Karadeniz in a claim against Pakistan; and meat processing group Gavrilovic in a claim against Croatia.
On the state side, it's defended Hungary in one ICSID matter and Mongolia in a US$600 million UNCITRAL claim brought by three Chinese entities. In 2015, China also listed Baker McKenzie on a panel of 15 international firms that will advise it on investment treaty matters. Kazakhstan's state-owned gas company KazTransGaz has turned to the firm for a potential Energy Charter Treaty claim against Georgia worth at least US$126 million.
In 2011, a team led by Hanessian helped Brazil's state oil and gas company Petrobras obtain a US$200 million award in a dispute with former Halliburton subsidiary KBR over faulty oil platforms. The parties settled in 2012, bringing an end to enforcement proceedings in New York.
Baker McKenzie brought in a great result for Weatherford in 2014, winning a US$45 million award against Dubai's Gulf Oil and Gas in an ICC dispute over the development of a gas field in Turkmenistan.
In Prague, Martin Hrodek led a team that achieved an US$85 million award for Czech bank CSOB in 2011 in an ICC claim against the Czech Republic. It was one of the first arbitrations to consider the application of state aid laws to a bank bailout.
The firm has also had success defending states. Baker McKenzie's associated Peruvian firm, Estudio Echecopar, helped the government of Peru bring an end to a dispute with two Spanish power companies that had spawned three ICSID cases. The investors paid US$40 million to the state as part of the settlement. White & Case was co-counsel in that matter.
For Uzbekistan, Baker McKenzie secured a precedent-setting award in favour of Uzbekistan in 2009 when a case brought by Swiss wheat trader Romak was dismissed at the jurisdictional stage, with the tribunal drawing a distinction between "investments" in a country and one-off transactions.
The firm has also successfully defended Turkey in two arbitrations under the Poland–Turkey BIT, and Papua New Guinea in an ICDR arbitration seated in New York.
In 2015, the firm helped Visor Capital settle a US$700 million ICSID claim against Kyrgyzstan over the country's second-largest gold deposit.
The Lima office brought in another ICSID win for Peru as co-counsel with White & Case, helping to knock out an US$800 million claim by the US's Renco Group concerning liability for an environmental clean-up at a smelting facility. Peru's counsel were able to show that the claimant hadn't complied with a treaty requirement to waive its right to pursue court litigation over the same dispute. A new ICSID claim may yet be filed, however.
In another ICSID case, the firm failed to prevent Hungary from being ordered to compensate a French corporate services provider, Edenred, but did succeed in reducing the damages to one-quarter of what had been claimed.
The Miami office represented US real estate developer IBT Group in three cases against Panama (two at the ICC and one at ICSID) relating to various hospitals, medical centres and asphalt plants in the country. The disputes were settled, with the client recovering everything it sought without jeopardising its relationship with the state.
The team in Frankfurt continued its representation of Siemens in a €5.8 billion ICC case against Finnish utility TVO over the construction of a nuclear power plant in Finland. A Stockholm-seated tribunal issued a partial award in late 2016 that TVO says went mostly in its favour, but that interpretation is disputed and the case still has some way to run before a final award.
The Frankfurt office also acted for an energy consortium made up of Germany's STEAG and Austria's EVN in a €1.2 billion ICC case against members of Japan's Hitachi group concerning delays in the construction of a power plant on the Rhine. The consortium announced in late 2016 that it had won an award worth €200 million though the actual value is contested by the other side. Baker McKenzie is advising the same client in a parallel ICC case concerning alleged technical shortcomings at the plant, which has yet to see an award.
Members of the firm's West Coast practice persuaded a California court to freeze the assets of a Russian former politician in support of efforts to enforce an LCIA award issued in favour of Russian businessman Vitaly Smagin in a dispute over a Moscow mall.
The practice announced five partner hires in 2016, the most significant being US-born energy disputes specialist Andy Moody, who joined the London office after five years at Eversheds. Former K&L Gates partner JP Duffy joined in New York while Charlotte Biljani joined the Dubai office after six years at Norton Rose Fulbright. The Johannesburg office welcomed Sonia de Vries and Adine Abro from South African firm Cliffe Dekker Hofmeyr.
It also made up several new partners: Teresa Michaud in San Francisco, Kate Corby in London, Tiago Zapater in São Paulo, Itse Oosterhoof in Amsterdam, and Elaine Yap and Arief Emran Arifin in Kuala Lumpur.
In Chile, José Joaquín Ugarte and Santiago Ried left the firm to set up their own boutique with another former Baker McKenzie partner, Pablo Correa.
Client comment
"Their dedication to the case is what we appreciate the most," says Laura Anguera Armengol, director of legal services at football team FC Barcelona, which used the firm for an arbitration worth almost €40 million. She also praises "their dedication to the preparation of the witnesses and the hearing".
Michael McNicholas, general counsel at Visor, says the firm was "very responsive" in its work on the Kyrgyzstan case mentioned above. They gave "solid legal advice" and "put together a strong cross-border litigation team", he adds.
The Arbitration Review of the Americas 2020
A Bridge too Far? The European Commission takes its Campaign against Intra-EU Investment Arbitration to US Courts
The Initial Hearing
The Role of Sovereign Wealth Funds and National Oil Companies in Investment Arbitrations

redpajama_set_name: RedPajamaCommonCrawl


The fragrance market is flooded with Eau de Parfums and Eau de Toilettes. Extracts – parfums – are harder to come by in North America. I recently got my hands on a few perfumes from the house of Guerlain. One of these was Nahema.
Nahema is a definitive rose, slightly green and woody, but mainly floral. The perfume concentration is very warm and I did not notice any green nuances. Rose opens with peach, followed by more rose and lilac in the midnotes. Peru balsam in the drydown pushes the composition into a balsamic accord, but, again, the perfume is more floral. The extract, with its quality ingredients, gives a rich and nuanced impression. The classic rose and lilac pairing echos the Victorian era. The scent lasts for about 10 hours staying close to the wearer – dense and decadent.
The first time I tried Nahema perfume, I was pleased by its old-fashioned, maternal motif. I remember applying makeup in front of the mirror while inhaling the scent, and smiling at how sophisticated it made me feel. It also reminded me of my Mother's lipstick. Despite this association, it felt like my perfume – suited for me. Nahema is best used as a winter or autumn fragrance because of its density, or at night for its sensuality.
Guerlain Nahema Perfume: 30ml bottle for £161.60 @ Escentual.com.


In this fast pace modern life...there are few things which are part and parcel in our daily life. One to name among them is the "GAS CYLINDER".
This message is been issued in view of Public safety and security by my gas stockiest.
Please read the below mail.....for our daily life safety.
How to find LPG cylinder's expiry date ?
Do you know that there is an expiry date (physical life) for LPG cylinders?
Expired Cylinders are not safe for use and may cause accidents. In this regard please be cautious at the time of accepting any LPG cylinder from the Vendor.
The digits stand for the year till it is valid.
Hence D06 would mean December qtr of 2006.
Share this message with everyone you know, UR kind cooperation will Save the life of many people and create awareness among the public.


text:
Notre-Dame-du-Lac foi uma cidade no RMC de Témiscouata, na região de Bas-Saint-Laurent, no Quebec, Canadá. A 5 de maio de 2010, as cidades de Cabano e Notre-Dame-du-Lac se uniram para formar a cidade de Témiscouata-sur-le-Lac. Notre-Dame-du-Lac foi designado como uma seção da nova cidade. Em 2016, a seção de Notre-Dame-du-Lac tinha uma população de 1184 habitantes.

Referências

Cidades do Quebec

redpajama_set_name: RedPajamaWikipedia


text:
News Bengali
Arpita Pal Chatterjee to play an IPS officer in Rajorshi Dey's Rifle
The film has an interesting storyline that focuses on an illegal racket using coins to make arms.
Kolkata - 10 Jun 2019 16:00 IST
Actress Arpita Pal Chatterjee will play an Indian Police Service (IPS) officer in Rajorshi Dey's upcoming crime thriller Rifle (2019). Based on Rupak Saha's unpublished story Khuchro Poysar Jonyo, the film will also feature Pujarini Ghosh, Rudranil Ghosh, Babul Supriyo, Kamaleswar Mukherjee, Padmanabha Dasgupta, Pallavi Chatterjee and others.
According to the director, factories for making these arms illegally out of the resilient metals used for coins, are being set up in the border areas of Bangladesh, including Kaliachak, Malda district.
In an interview with Sangbad Pratidin, Dey commented, "This racket is a reality, but no media houses or the police department talk about it. I will try to throw light on the issue through the film."
The film will also have subplots of terrorist activities and showcases different kinds of crimes. A cricket team will also be involved in the plot.
"How the police officer manages to rescue a women's cricket team from an explosion will remain at the core of the thriller element of the film," added Dey.
The dialogues and screenplay of the film has been written by Sougata Basu. Cinematographer Gopi Bhagat will shoot the film, while Sanjib Dutta will edit and Ashu Chakraborty will score the music of Rifle.
Rajorshi Dey's two more films Purba, Pashchim, Dakshin (Uttar Asbei) and Shubho Noboborsho are yet to release in this year.
Raajhorshee De
Script Supervisor, Actor, Director
Arpita Pal Chatterjee