/**
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 * SPDX-License-Identifier: Apache-2.0.
 */

#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/rds/RDSRequest.h>
#include <aws/rds/RDS_EXPORTS.h>
#include <aws/rds/model/ServerlessV2ScalingConfiguration.h>
#include <aws/rds/model/Tag.h>
#include <aws/rds/model/TagSpecification.h>

#include <utility>

namespace Aws {
namespace RDS {
namespace Model {

/**
 */
class RestoreDBClusterFromS3Request : public RDSRequest {
 public:
  AWS_RDS_API RestoreDBClusterFromS3Request() = default;

  // 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 "RestoreDBClusterFromS3"; }

  AWS_RDS_API Aws::String SerializePayload() const override;

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

 public:
  ///@{
  /**
   * <p>A list of Availability Zones (AZs) where instances in the restored DB cluster
   * can be created.</p>
   */
  inline const Aws::Vector<Aws::String>& GetAvailabilityZones() const { return m_availabilityZones; }
  inline bool AvailabilityZonesHasBeenSet() const { return m_availabilityZonesHasBeenSet; }
  template <typename AvailabilityZonesT = Aws::Vector<Aws::String>>
  void SetAvailabilityZones(AvailabilityZonesT&& value) {
    m_availabilityZonesHasBeenSet = true;
    m_availabilityZones = std::forward<AvailabilityZonesT>(value);
  }
  template <typename AvailabilityZonesT = Aws::Vector<Aws::String>>
  RestoreDBClusterFromS3Request& WithAvailabilityZones(AvailabilityZonesT&& value) {
    SetAvailabilityZones(std::forward<AvailabilityZonesT>(value));
    return *this;
  }
  template <typename AvailabilityZonesT = Aws::String>
  RestoreDBClusterFromS3Request& AddAvailabilityZones(AvailabilityZonesT&& value) {
    m_availabilityZonesHasBeenSet = true;
    m_availabilityZones.emplace_back(std::forward<AvailabilityZonesT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The number of days for which automated backups of the restored DB cluster are
   * retained. You must specify a minimum value of 1.</p> <p>Default: 1</p>
   * <p>Constraints:</p> <ul> <li> <p>Must be a value from 1 to 35</p> </li> </ul>
   */
  inline int GetBackupRetentionPeriod() const { return m_backupRetentionPeriod; }
  inline bool BackupRetentionPeriodHasBeenSet() const { return m_backupRetentionPeriodHasBeenSet; }
  inline void SetBackupRetentionPeriod(int value) {
    m_backupRetentionPeriodHasBeenSet = true;
    m_backupRetentionPeriod = value;
  }
  inline RestoreDBClusterFromS3Request& WithBackupRetentionPeriod(int value) {
    SetBackupRetentionPeriod(value);
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>A value that indicates that the restored DB cluster should be associated with
   * the specified CharacterSet.</p>
   */
  inline const Aws::String& GetCharacterSetName() const { return m_characterSetName; }
  inline bool CharacterSetNameHasBeenSet() const { return m_characterSetNameHasBeenSet; }
  template <typename CharacterSetNameT = Aws::String>
  void SetCharacterSetName(CharacterSetNameT&& value) {
    m_characterSetNameHasBeenSet = true;
    m_characterSetName = std::forward<CharacterSetNameT>(value);
  }
  template <typename CharacterSetNameT = Aws::String>
  RestoreDBClusterFromS3Request& WithCharacterSetName(CharacterSetNameT&& value) {
    SetCharacterSetName(std::forward<CharacterSetNameT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The database name for the restored DB cluster.</p>
   */
  inline const Aws::String& GetDatabaseName() const { return m_databaseName; }
  inline bool DatabaseNameHasBeenSet() const { return m_databaseNameHasBeenSet; }
  template <typename DatabaseNameT = Aws::String>
  void SetDatabaseName(DatabaseNameT&& value) {
    m_databaseNameHasBeenSet = true;
    m_databaseName = std::forward<DatabaseNameT>(value);
  }
  template <typename DatabaseNameT = Aws::String>
  RestoreDBClusterFromS3Request& WithDatabaseName(DatabaseNameT&& value) {
    SetDatabaseName(std::forward<DatabaseNameT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The name of the DB cluster to create from the source data in the Amazon S3
   * bucket. This parameter isn't case-sensitive.</p> <p>Constraints:</p> <ul> <li>
   * <p>Must contain from 1 to 63 letters, numbers, or hyphens.</p> </li> <li>
   * <p>First character must be a letter.</p> </li> <li> <p>Can't end with a hyphen
   * or contain two consecutive hyphens.</p> </li> </ul> <p>Example:
   * <code>my-cluster1</code> </p>
   */
  inline const Aws::String& GetDBClusterIdentifier() const { return m_dBClusterIdentifier; }
  inline bool DBClusterIdentifierHasBeenSet() const { return m_dBClusterIdentifierHasBeenSet; }
  template <typename DBClusterIdentifierT = Aws::String>
  void SetDBClusterIdentifier(DBClusterIdentifierT&& value) {
    m_dBClusterIdentifierHasBeenSet = true;
    m_dBClusterIdentifier = std::forward<DBClusterIdentifierT>(value);
  }
  template <typename DBClusterIdentifierT = Aws::String>
  RestoreDBClusterFromS3Request& WithDBClusterIdentifier(DBClusterIdentifierT&& value) {
    SetDBClusterIdentifier(std::forward<DBClusterIdentifierT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The name of the DB cluster parameter group to associate with the restored DB
   * cluster. If this argument is omitted, the default parameter group for the engine
   * version is used.</p> <p>Constraints:</p> <ul> <li> <p>If supplied, must match
   * the name of an existing DBClusterParameterGroup.</p> </li> </ul>
   */
  inline const Aws::String& GetDBClusterParameterGroupName() const { return m_dBClusterParameterGroupName; }
  inline bool DBClusterParameterGroupNameHasBeenSet() const { return m_dBClusterParameterGroupNameHasBeenSet; }
  template <typename DBClusterParameterGroupNameT = Aws::String>
  void SetDBClusterParameterGroupName(DBClusterParameterGroupNameT&& value) {
    m_dBClusterParameterGroupNameHasBeenSet = true;
    m_dBClusterParameterGroupName = std::forward<DBClusterParameterGroupNameT>(value);
  }
  template <typename DBClusterParameterGroupNameT = Aws::String>
  RestoreDBClusterFromS3Request& WithDBClusterParameterGroupName(DBClusterParameterGroupNameT&& value) {
    SetDBClusterParameterGroupName(std::forward<DBClusterParameterGroupNameT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>A list of EC2 VPC security groups to associate with the restored DB
   * cluster.</p>
   */
  inline const Aws::Vector<Aws::String>& GetVpcSecurityGroupIds() const { return m_vpcSecurityGroupIds; }
  inline bool VpcSecurityGroupIdsHasBeenSet() const { return m_vpcSecurityGroupIdsHasBeenSet; }
  template <typename VpcSecurityGroupIdsT = Aws::Vector<Aws::String>>
  void SetVpcSecurityGroupIds(VpcSecurityGroupIdsT&& value) {
    m_vpcSecurityGroupIdsHasBeenSet = true;
    m_vpcSecurityGroupIds = std::forward<VpcSecurityGroupIdsT>(value);
  }
  template <typename VpcSecurityGroupIdsT = Aws::Vector<Aws::String>>
  RestoreDBClusterFromS3Request& WithVpcSecurityGroupIds(VpcSecurityGroupIdsT&& value) {
    SetVpcSecurityGroupIds(std::forward<VpcSecurityGroupIdsT>(value));
    return *this;
  }
  template <typename VpcSecurityGroupIdsT = Aws::String>
  RestoreDBClusterFromS3Request& AddVpcSecurityGroupIds(VpcSecurityGroupIdsT&& value) {
    m_vpcSecurityGroupIdsHasBeenSet = true;
    m_vpcSecurityGroupIds.emplace_back(std::forward<VpcSecurityGroupIdsT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>A DB subnet group to associate with the restored DB cluster.</p>
   * <p>Constraints: If supplied, must match the name of an existing
   * DBSubnetGroup.</p> <p>Example: <code>mydbsubnetgroup</code> </p>
   */
  inline const Aws::String& GetDBSubnetGroupName() const { return m_dBSubnetGroupName; }
  inline bool DBSubnetGroupNameHasBeenSet() const { return m_dBSubnetGroupNameHasBeenSet; }
  template <typename DBSubnetGroupNameT = Aws::String>
  void SetDBSubnetGroupName(DBSubnetGroupNameT&& value) {
    m_dBSubnetGroupNameHasBeenSet = true;
    m_dBSubnetGroupName = std::forward<DBSubnetGroupNameT>(value);
  }
  template <typename DBSubnetGroupNameT = Aws::String>
  RestoreDBClusterFromS3Request& WithDBSubnetGroupName(DBSubnetGroupNameT&& value) {
    SetDBSubnetGroupName(std::forward<DBSubnetGroupNameT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The name of the database engine to be used for this DB cluster.</p> <p>Valid
   * Values: <code>aurora-mysql</code> (for Aurora MySQL)</p>
   */
  inline const Aws::String& GetEngine() const { return m_engine; }
  inline bool EngineHasBeenSet() const { return m_engineHasBeenSet; }
  template <typename EngineT = Aws::String>
  void SetEngine(EngineT&& value) {
    m_engineHasBeenSet = true;
    m_engine = std::forward<EngineT>(value);
  }
  template <typename EngineT = Aws::String>
  RestoreDBClusterFromS3Request& WithEngine(EngineT&& value) {
    SetEngine(std::forward<EngineT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The version number of the database engine to use.</p> <p>To list all of the
   * available engine versions for <code>aurora-mysql</code> (Aurora MySQL), use the
   * following command:</p> <p> <code>aws rds describe-db-engine-versions --engine
   * aurora-mysql --query "DBEngineVersions[].EngineVersion"</code> </p> <p>
   * <b>Aurora MySQL</b> </p> <p>Examples: <code>5.7.mysql_aurora.2.12.0</code>,
   * <code>8.0.mysql_aurora.3.04.0</code> </p>
   */
  inline const Aws::String& GetEngineVersion() const { return m_engineVersion; }
  inline bool EngineVersionHasBeenSet() const { return m_engineVersionHasBeenSet; }
  template <typename EngineVersionT = Aws::String>
  void SetEngineVersion(EngineVersionT&& value) {
    m_engineVersionHasBeenSet = true;
    m_engineVersion = std::forward<EngineVersionT>(value);
  }
  template <typename EngineVersionT = Aws::String>
  RestoreDBClusterFromS3Request& WithEngineVersion(EngineVersionT&& value) {
    SetEngineVersion(std::forward<EngineVersionT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The port number on which the instances in the restored DB cluster accept
   * connections.</p> <p>Default: <code>3306</code> </p>
   */
  inline int GetPort() const { return m_port; }
  inline bool PortHasBeenSet() const { return m_portHasBeenSet; }
  inline void SetPort(int value) {
    m_portHasBeenSet = true;
    m_port = value;
  }
  inline RestoreDBClusterFromS3Request& WithPort(int value) {
    SetPort(value);
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The name of the master user for the restored DB cluster.</p>
   * <p>Constraints:</p> <ul> <li> <p>Must be 1 to 16 letters or numbers.</p> </li>
   * <li> <p>First character must be a letter.</p> </li> <li> <p>Can't be a reserved
   * word for the chosen database engine.</p> </li> </ul>
   */
  inline const Aws::String& GetMasterUsername() const { return m_masterUsername; }
  inline bool MasterUsernameHasBeenSet() const { return m_masterUsernameHasBeenSet; }
  template <typename MasterUsernameT = Aws::String>
  void SetMasterUsername(MasterUsernameT&& value) {
    m_masterUsernameHasBeenSet = true;
    m_masterUsername = std::forward<MasterUsernameT>(value);
  }
  template <typename MasterUsernameT = Aws::String>
  RestoreDBClusterFromS3Request& WithMasterUsername(MasterUsernameT&& value) {
    SetMasterUsername(std::forward<MasterUsernameT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The password for the master database user. This password can contain any
   * printable ASCII character except "/", """, or "@".</p> <p>Constraints:</p> <ul>
   * <li> <p>Must contain from 8 to 41 characters.</p> </li> <li> <p>Can't be
   * specified if <code>ManageMasterUserPassword</code> is turned on.</p> </li> </ul>
   */
  inline const Aws::String& GetMasterUserPassword() const { return m_masterUserPassword; }
  inline bool MasterUserPasswordHasBeenSet() const { return m_masterUserPasswordHasBeenSet; }
  template <typename MasterUserPasswordT = Aws::String>
  void SetMasterUserPassword(MasterUserPasswordT&& value) {
    m_masterUserPasswordHasBeenSet = true;
    m_masterUserPassword = std::forward<MasterUserPasswordT>(value);
  }
  template <typename MasterUserPasswordT = Aws::String>
  RestoreDBClusterFromS3Request& WithMasterUserPassword(MasterUserPasswordT&& value) {
    SetMasterUserPassword(std::forward<MasterUserPasswordT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>A value that indicates that the restored DB cluster should be associated with
   * the specified option group.</p> <p>Permanent options can't be removed from an
   * option group. An option group can't be removed from a DB cluster once it is
   * associated with a DB cluster.</p>
   */
  inline const Aws::String& GetOptionGroupName() const { return m_optionGroupName; }
  inline bool OptionGroupNameHasBeenSet() const { return m_optionGroupNameHasBeenSet; }
  template <typename OptionGroupNameT = Aws::String>
  void SetOptionGroupName(OptionGroupNameT&& value) {
    m_optionGroupNameHasBeenSet = true;
    m_optionGroupName = std::forward<OptionGroupNameT>(value);
  }
  template <typename OptionGroupNameT = Aws::String>
  RestoreDBClusterFromS3Request& WithOptionGroupName(OptionGroupNameT&& value) {
    SetOptionGroupName(std::forward<OptionGroupNameT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The daily time range during which automated backups are created if automated
   * backups are enabled using the <code>BackupRetentionPeriod</code> parameter.</p>
   * <p>The default is a 30-minute window selected at random from an 8-hour block of
   * time for each Amazon Web Services Region. To view the time blocks available, see
   * <a
   * href="https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.Managing.Backups.html#Aurora.Managing.Backups.BackupWindow">
   * Backup window</a> in the <i>Amazon Aurora User Guide</i>.</p>
   * <p>Constraints:</p> <ul> <li> <p>Must be in the format
   * <code>hh24:mi-hh24:mi</code>.</p> </li> <li> <p>Must be in Universal Coordinated
   * Time (UTC).</p> </li> <li> <p>Must not conflict with the preferred maintenance
   * window.</p> </li> <li> <p>Must be at least 30 minutes.</p> </li> </ul>
   */
  inline const Aws::String& GetPreferredBackupWindow() const { return m_preferredBackupWindow; }
  inline bool PreferredBackupWindowHasBeenSet() const { return m_preferredBackupWindowHasBeenSet; }
  template <typename PreferredBackupWindowT = Aws::String>
  void SetPreferredBackupWindow(PreferredBackupWindowT&& value) {
    m_preferredBackupWindowHasBeenSet = true;
    m_preferredBackupWindow = std::forward<PreferredBackupWindowT>(value);
  }
  template <typename PreferredBackupWindowT = Aws::String>
  RestoreDBClusterFromS3Request& WithPreferredBackupWindow(PreferredBackupWindowT&& value) {
    SetPreferredBackupWindow(std::forward<PreferredBackupWindowT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The weekly time range during which system maintenance can occur, in Universal
   * Coordinated Time (UTC).</p> <p>Format: <code>ddd:hh24:mi-ddd:hh24:mi</code> </p>
   * <p>The default is a 30-minute window selected at random from an 8-hour block of
   * time for each Amazon Web Services Region, occurring on a random day of the week.
   * To see the time blocks available, see <a
   * href="https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_UpgradeDBInstance.Maintenance.html#AdjustingTheMaintenanceWindow.Aurora">
   * Adjusting the Preferred Maintenance Window</a> in the <i>Amazon Aurora User
   * Guide</i>.</p> <p>Valid Days: Mon, Tue, Wed, Thu, Fri, Sat, Sun.</p>
   * <p>Constraints: Minimum 30-minute window.</p>
   */
  inline const Aws::String& GetPreferredMaintenanceWindow() const { return m_preferredMaintenanceWindow; }
  inline bool PreferredMaintenanceWindowHasBeenSet() const { return m_preferredMaintenanceWindowHasBeenSet; }
  template <typename PreferredMaintenanceWindowT = Aws::String>
  void SetPreferredMaintenanceWindow(PreferredMaintenanceWindowT&& value) {
    m_preferredMaintenanceWindowHasBeenSet = true;
    m_preferredMaintenanceWindow = std::forward<PreferredMaintenanceWindowT>(value);
  }
  template <typename PreferredMaintenanceWindowT = Aws::String>
  RestoreDBClusterFromS3Request& WithPreferredMaintenanceWindow(PreferredMaintenanceWindowT&& value) {
    SetPreferredMaintenanceWindow(std::forward<PreferredMaintenanceWindowT>(value));
    return *this;
  }
  ///@}

  ///@{

  inline const Aws::Vector<Tag>& GetTags() const { return m_tags; }
  inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
  template <typename TagsT = Aws::Vector<Tag>>
  void SetTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags = std::forward<TagsT>(value);
  }
  template <typename TagsT = Aws::Vector<Tag>>
  RestoreDBClusterFromS3Request& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsT = Tag>
  RestoreDBClusterFromS3Request& AddTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace_back(std::forward<TagsT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>Specifies whether the restored DB cluster is encrypted.</p>
   */
  inline bool GetStorageEncrypted() const { return m_storageEncrypted; }
  inline bool StorageEncryptedHasBeenSet() const { return m_storageEncryptedHasBeenSet; }
  inline void SetStorageEncrypted(bool value) {
    m_storageEncryptedHasBeenSet = true;
    m_storageEncrypted = value;
  }
  inline RestoreDBClusterFromS3Request& WithStorageEncrypted(bool value) {
    SetStorageEncrypted(value);
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The Amazon Web Services KMS key identifier for an encrypted DB cluster.</p>
   * <p>The Amazon Web Services KMS key identifier is the key ARN, key ID, alias ARN,
   * or alias name for the KMS key. To use a KMS key in a different Amazon Web
   * Services account, specify the key ARN or alias ARN.</p> <p>If the
   * StorageEncrypted parameter is enabled, and you do not specify a value for the
   * <code>KmsKeyId</code> parameter, then Amazon RDS will use your default KMS key.
   * There is a default KMS key for your Amazon Web Services account. Your Amazon Web
   * Services account has a different default KMS key for each Amazon Web Services
   * Region.</p>
   */
  inline const Aws::String& GetKmsKeyId() const { return m_kmsKeyId; }
  inline bool KmsKeyIdHasBeenSet() const { return m_kmsKeyIdHasBeenSet; }
  template <typename KmsKeyIdT = Aws::String>
  void SetKmsKeyId(KmsKeyIdT&& value) {
    m_kmsKeyIdHasBeenSet = true;
    m_kmsKeyId = std::forward<KmsKeyIdT>(value);
  }
  template <typename KmsKeyIdT = Aws::String>
  RestoreDBClusterFromS3Request& WithKmsKeyId(KmsKeyIdT&& value) {
    SetKmsKeyId(std::forward<KmsKeyIdT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>Specifies whether to enable mapping of Amazon Web Services Identity and
   * Access Management (IAM) accounts to database accounts. By default, mapping isn't
   * enabled.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/UsingWithRDS.IAMDBAuth.html">
   * IAM Database Authentication</a> in the <i>Amazon Aurora User Guide</i>.</p>
   */
  inline bool GetEnableIAMDatabaseAuthentication() const { return m_enableIAMDatabaseAuthentication; }
  inline bool EnableIAMDatabaseAuthenticationHasBeenSet() const { return m_enableIAMDatabaseAuthenticationHasBeenSet; }
  inline void SetEnableIAMDatabaseAuthentication(bool value) {
    m_enableIAMDatabaseAuthenticationHasBeenSet = true;
    m_enableIAMDatabaseAuthentication = value;
  }
  inline RestoreDBClusterFromS3Request& WithEnableIAMDatabaseAuthentication(bool value) {
    SetEnableIAMDatabaseAuthentication(value);
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The identifier for the database engine that was backed up to create the files
   * stored in the Amazon S3 bucket.</p> <p>Valid Values: <code>mysql</code> </p>
   */
  inline const Aws::String& GetSourceEngine() const { return m_sourceEngine; }
  inline bool SourceEngineHasBeenSet() const { return m_sourceEngineHasBeenSet; }
  template <typename SourceEngineT = Aws::String>
  void SetSourceEngine(SourceEngineT&& value) {
    m_sourceEngineHasBeenSet = true;
    m_sourceEngine = std::forward<SourceEngineT>(value);
  }
  template <typename SourceEngineT = Aws::String>
  RestoreDBClusterFromS3Request& WithSourceEngine(SourceEngineT&& value) {
    SetSourceEngine(std::forward<SourceEngineT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The version of the database that the backup files were created from.</p>
   * <p>MySQL versions 5.7 and 8.0 are supported.</p> <p>Example:
   * <code>5.7.40</code>, <code>8.0.28</code> </p>
   */
  inline const Aws::String& GetSourceEngineVersion() const { return m_sourceEngineVersion; }
  inline bool SourceEngineVersionHasBeenSet() const { return m_sourceEngineVersionHasBeenSet; }
  template <typename SourceEngineVersionT = Aws::String>
  void SetSourceEngineVersion(SourceEngineVersionT&& value) {
    m_sourceEngineVersionHasBeenSet = true;
    m_sourceEngineVersion = std::forward<SourceEngineVersionT>(value);
  }
  template <typename SourceEngineVersionT = Aws::String>
  RestoreDBClusterFromS3Request& WithSourceEngineVersion(SourceEngineVersionT&& value) {
    SetSourceEngineVersion(std::forward<SourceEngineVersionT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The name of the Amazon S3 bucket that contains the data used to create the
   * Amazon Aurora DB cluster.</p>
   */
  inline const Aws::String& GetS3BucketName() const { return m_s3BucketName; }
  inline bool S3BucketNameHasBeenSet() const { return m_s3BucketNameHasBeenSet; }
  template <typename S3BucketNameT = Aws::String>
  void SetS3BucketName(S3BucketNameT&& value) {
    m_s3BucketNameHasBeenSet = true;
    m_s3BucketName = std::forward<S3BucketNameT>(value);
  }
  template <typename S3BucketNameT = Aws::String>
  RestoreDBClusterFromS3Request& WithS3BucketName(S3BucketNameT&& value) {
    SetS3BucketName(std::forward<S3BucketNameT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The prefix for all of the file names that contain the data used to create the
   * Amazon Aurora DB cluster. If you do not specify a <b>SourceS3Prefix</b> value,
   * then the Amazon Aurora DB cluster is created by using all of the files in the
   * Amazon S3 bucket.</p>
   */
  inline const Aws::String& GetS3Prefix() const { return m_s3Prefix; }
  inline bool S3PrefixHasBeenSet() const { return m_s3PrefixHasBeenSet; }
  template <typename S3PrefixT = Aws::String>
  void SetS3Prefix(S3PrefixT&& value) {
    m_s3PrefixHasBeenSet = true;
    m_s3Prefix = std::forward<S3PrefixT>(value);
  }
  template <typename S3PrefixT = Aws::String>
  RestoreDBClusterFromS3Request& WithS3Prefix(S3PrefixT&& value) {
    SetS3Prefix(std::forward<S3PrefixT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The Amazon Resource Name (ARN) of the Amazon Web Services Identity and Access
   * Management (IAM) role that authorizes Amazon RDS to access the Amazon S3 bucket
   * on your behalf.</p>
   */
  inline const Aws::String& GetS3IngestionRoleArn() const { return m_s3IngestionRoleArn; }
  inline bool S3IngestionRoleArnHasBeenSet() const { return m_s3IngestionRoleArnHasBeenSet; }
  template <typename S3IngestionRoleArnT = Aws::String>
  void SetS3IngestionRoleArn(S3IngestionRoleArnT&& value) {
    m_s3IngestionRoleArnHasBeenSet = true;
    m_s3IngestionRoleArn = std::forward<S3IngestionRoleArnT>(value);
  }
  template <typename S3IngestionRoleArnT = Aws::String>
  RestoreDBClusterFromS3Request& WithS3IngestionRoleArn(S3IngestionRoleArnT&& value) {
    SetS3IngestionRoleArn(std::forward<S3IngestionRoleArnT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The target backtrack window, in seconds. To disable backtracking, set this
   * value to 0.</p>  <p>Currently, Backtrack is only supported for Aurora
   * MySQL DB clusters.</p>  <p>Default: 0</p> <p>Constraints:</p> <ul> <li>
   * <p>If specified, this value must be set to a number from 0 to 259,200 (72
   * hours).</p> </li> </ul>
   */
  inline long long GetBacktrackWindow() const { return m_backtrackWindow; }
  inline bool BacktrackWindowHasBeenSet() const { return m_backtrackWindowHasBeenSet; }
  inline void SetBacktrackWindow(long long value) {
    m_backtrackWindowHasBeenSet = true;
    m_backtrackWindow = value;
  }
  inline RestoreDBClusterFromS3Request& WithBacktrackWindow(long long value) {
    SetBacktrackWindow(value);
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The list of logs that the restored DB cluster is to export to CloudWatch
   * Logs. The values in the list depend on the DB engine being used.</p> <p>
   * <b>Aurora MySQL</b> </p> <p>Possible values are <code>audit</code>,
   * <code>error</code>, <code>general</code>, <code>instance</code>,
   * <code>slowquery</code>, and <code>iam-db-auth-error</code>.</p> <p> <b>Aurora
   * PostgreSQL</b> </p> <p>Possible value are <code>instance</code>,
   * <code>postgresql</code>, and <code>iam-db-auth-error</code>.</p> <p>For more
   * information about exporting CloudWatch Logs for Amazon RDS, see <a
   * href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_LogAccess.html#USER_LogAccess.Procedural.UploadtoCloudWatch">Publishing
   * Database Logs to Amazon CloudWatch Logs</a> in the <i>Amazon RDS User
   * Guide</i>.</p> <p>For more information about exporting CloudWatch Logs for
   * Amazon Aurora, see <a
   * href="https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_LogAccess.html#USER_LogAccess.Procedural.UploadtoCloudWatch">Publishing
   * Database Logs to Amazon CloudWatch Logs</a> in the <i>Amazon Aurora User
   * Guide</i>.</p>
   */
  inline const Aws::Vector<Aws::String>& GetEnableCloudwatchLogsExports() const { return m_enableCloudwatchLogsExports; }
  inline bool EnableCloudwatchLogsExportsHasBeenSet() const { return m_enableCloudwatchLogsExportsHasBeenSet; }
  template <typename EnableCloudwatchLogsExportsT = Aws::Vector<Aws::String>>
  void SetEnableCloudwatchLogsExports(EnableCloudwatchLogsExportsT&& value) {
    m_enableCloudwatchLogsExportsHasBeenSet = true;
    m_enableCloudwatchLogsExports = std::forward<EnableCloudwatchLogsExportsT>(value);
  }
  template <typename EnableCloudwatchLogsExportsT = Aws::Vector<Aws::String>>
  RestoreDBClusterFromS3Request& WithEnableCloudwatchLogsExports(EnableCloudwatchLogsExportsT&& value) {
    SetEnableCloudwatchLogsExports(std::forward<EnableCloudwatchLogsExportsT>(value));
    return *this;
  }
  template <typename EnableCloudwatchLogsExportsT = Aws::String>
  RestoreDBClusterFromS3Request& AddEnableCloudwatchLogsExports(EnableCloudwatchLogsExportsT&& value) {
    m_enableCloudwatchLogsExportsHasBeenSet = true;
    m_enableCloudwatchLogsExports.emplace_back(std::forward<EnableCloudwatchLogsExportsT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>Specifies whether to enable deletion protection for the DB cluster. The
   * database can't be deleted when deletion protection is enabled. By default,
   * deletion protection isn't enabled.</p>
   */
  inline bool GetDeletionProtection() const { return m_deletionProtection; }
  inline bool DeletionProtectionHasBeenSet() const { return m_deletionProtectionHasBeenSet; }
  inline void SetDeletionProtection(bool value) {
    m_deletionProtectionHasBeenSet = true;
    m_deletionProtection = value;
  }
  inline RestoreDBClusterFromS3Request& WithDeletionProtection(bool value) {
    SetDeletionProtection(value);
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>Specifies whether to copy all tags from the restored DB cluster to snapshots
   * of the restored DB cluster. The default is not to copy them.</p>
   */
  inline bool GetCopyTagsToSnapshot() const { return m_copyTagsToSnapshot; }
  inline bool CopyTagsToSnapshotHasBeenSet() const { return m_copyTagsToSnapshotHasBeenSet; }
  inline void SetCopyTagsToSnapshot(bool value) {
    m_copyTagsToSnapshotHasBeenSet = true;
    m_copyTagsToSnapshot = value;
  }
  inline RestoreDBClusterFromS3Request& WithCopyTagsToSnapshot(bool value) {
    SetCopyTagsToSnapshot(value);
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>Specify the Active Directory directory ID to restore the DB cluster in. The
   * domain must be created prior to this operation.</p> <p>For Amazon Aurora DB
   * clusters, Amazon RDS can use Kerberos Authentication to authenticate users that
   * connect to the DB cluster. For more information, see <a
   * href="https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/kerberos-authentication.html">Kerberos
   * Authentication</a> in the <i>Amazon Aurora User Guide</i>.</p>
   */
  inline const Aws::String& GetDomain() const { return m_domain; }
  inline bool DomainHasBeenSet() const { return m_domainHasBeenSet; }
  template <typename DomainT = Aws::String>
  void SetDomain(DomainT&& value) {
    m_domainHasBeenSet = true;
    m_domain = std::forward<DomainT>(value);
  }
  template <typename DomainT = Aws::String>
  RestoreDBClusterFromS3Request& WithDomain(DomainT&& value) {
    SetDomain(std::forward<DomainT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>Specify the name of the IAM role to be used when making API calls to the
   * Directory Service.</p>
   */
  inline const Aws::String& GetDomainIAMRoleName() const { return m_domainIAMRoleName; }
  inline bool DomainIAMRoleNameHasBeenSet() const { return m_domainIAMRoleNameHasBeenSet; }
  template <typename DomainIAMRoleNameT = Aws::String>
  void SetDomainIAMRoleName(DomainIAMRoleNameT&& value) {
    m_domainIAMRoleNameHasBeenSet = true;
    m_domainIAMRoleName = std::forward<DomainIAMRoleNameT>(value);
  }
  template <typename DomainIAMRoleNameT = Aws::String>
  RestoreDBClusterFromS3Request& WithDomainIAMRoleName(DomainIAMRoleNameT&& value) {
    SetDomainIAMRoleName(std::forward<DomainIAMRoleNameT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>Specifies the storage type to be associated with the DB cluster.</p> <p>Valid
   * Values: <code>aurora</code>, <code>aurora-iopt1</code> </p> <p>Default:
   * <code>aurora</code> </p> <p>Valid for: Aurora DB clusters only</p>
   */
  inline const Aws::String& GetStorageType() const { return m_storageType; }
  inline bool StorageTypeHasBeenSet() const { return m_storageTypeHasBeenSet; }
  template <typename StorageTypeT = Aws::String>
  void SetStorageType(StorageTypeT&& value) {
    m_storageTypeHasBeenSet = true;
    m_storageType = std::forward<StorageTypeT>(value);
  }
  template <typename StorageTypeT = Aws::String>
  RestoreDBClusterFromS3Request& WithStorageType(StorageTypeT&& value) {
    SetStorageType(std::forward<StorageTypeT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The network type of the DB cluster.</p> <p>Valid Values:</p> <ul> <li> <p>
   * <code>IPV4</code> </p> </li> <li> <p> <code>DUAL</code> </p> </li> </ul> <p>The
   * network type is determined by the <code>DBSubnetGroup</code> specified for the
   * DB cluster. A <code>DBSubnetGroup</code> can support only the IPv4 protocol or
   * the IPv4 and the IPv6 protocols (<code>DUAL</code>).</p> <p>For more
   * information, see <a
   * href="https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_VPC.WorkingWithRDSInstanceinaVPC.html">
   * Working with a DB instance in a VPC</a> in the <i>Amazon Aurora User Guide.</i>
   * </p>
   */
  inline const Aws::String& GetNetworkType() const { return m_networkType; }
  inline bool NetworkTypeHasBeenSet() const { return m_networkTypeHasBeenSet; }
  template <typename NetworkTypeT = Aws::String>
  void SetNetworkType(NetworkTypeT&& value) {
    m_networkTypeHasBeenSet = true;
    m_networkType = std::forward<NetworkTypeT>(value);
  }
  template <typename NetworkTypeT = Aws::String>
  RestoreDBClusterFromS3Request& WithNetworkType(NetworkTypeT&& value) {
    SetNetworkType(std::forward<NetworkTypeT>(value));
    return *this;
  }
  ///@}

  ///@{

  inline const ServerlessV2ScalingConfiguration& GetServerlessV2ScalingConfiguration() const { return m_serverlessV2ScalingConfiguration; }
  inline bool ServerlessV2ScalingConfigurationHasBeenSet() const { return m_serverlessV2ScalingConfigurationHasBeenSet; }
  template <typename ServerlessV2ScalingConfigurationT = ServerlessV2ScalingConfiguration>
  void SetServerlessV2ScalingConfiguration(ServerlessV2ScalingConfigurationT&& value) {
    m_serverlessV2ScalingConfigurationHasBeenSet = true;
    m_serverlessV2ScalingConfiguration = std::forward<ServerlessV2ScalingConfigurationT>(value);
  }
  template <typename ServerlessV2ScalingConfigurationT = ServerlessV2ScalingConfiguration>
  RestoreDBClusterFromS3Request& WithServerlessV2ScalingConfiguration(ServerlessV2ScalingConfigurationT&& value) {
    SetServerlessV2ScalingConfiguration(std::forward<ServerlessV2ScalingConfigurationT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>Specifies whether to manage the master user password with Amazon Web Services
   * Secrets Manager.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-secrets-manager.html">Password
   * management with Amazon Web Services Secrets Manager</a> in the <i>Amazon RDS
   * User Guide</i> and <a
   * href="https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/rds-secrets-manager.html">Password
   * management with Amazon Web Services Secrets Manager</a> in the <i>Amazon Aurora
   * User Guide.</i> </p> <p>Constraints:</p> <ul> <li> <p>Can't manage the master
   * user password with Amazon Web Services Secrets Manager if
   * <code>MasterUserPassword</code> is specified.</p> </li> </ul>
   */
  inline bool GetManageMasterUserPassword() const { return m_manageMasterUserPassword; }
  inline bool ManageMasterUserPasswordHasBeenSet() const { return m_manageMasterUserPasswordHasBeenSet; }
  inline void SetManageMasterUserPassword(bool value) {
    m_manageMasterUserPasswordHasBeenSet = true;
    m_manageMasterUserPassword = value;
  }
  inline RestoreDBClusterFromS3Request& WithManageMasterUserPassword(bool value) {
    SetManageMasterUserPassword(value);
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The Amazon Web Services KMS key identifier to encrypt a secret that is
   * automatically generated and managed in Amazon Web Services Secrets Manager.</p>
   * <p>This setting is valid only if the master user password is managed by RDS in
   * Amazon Web Services Secrets Manager for the DB cluster.</p> <p>The Amazon Web
   * Services KMS key identifier is the key ARN, key ID, alias ARN, or alias name for
   * the KMS key. To use a KMS key in a different Amazon Web Services account,
   * specify the key ARN or alias ARN.</p> <p>If you don't specify
   * <code>MasterUserSecretKmsKeyId</code>, then the <code>aws/secretsmanager</code>
   * KMS key is used to encrypt the secret. If the secret is in a different Amazon
   * Web Services account, then you can't use the <code>aws/secretsmanager</code> KMS
   * key to encrypt the secret, and you must use a customer managed KMS key.</p>
   * <p>There is a default KMS key for your Amazon Web Services account. Your Amazon
   * Web Services account has a different default KMS key for each Amazon Web
   * Services Region.</p>
   */
  inline const Aws::String& GetMasterUserSecretKmsKeyId() const { return m_masterUserSecretKmsKeyId; }
  inline bool MasterUserSecretKmsKeyIdHasBeenSet() const { return m_masterUserSecretKmsKeyIdHasBeenSet; }
  template <typename MasterUserSecretKmsKeyIdT = Aws::String>
  void SetMasterUserSecretKmsKeyId(MasterUserSecretKmsKeyIdT&& value) {
    m_masterUserSecretKmsKeyIdHasBeenSet = true;
    m_masterUserSecretKmsKeyId = std::forward<MasterUserSecretKmsKeyIdT>(value);
  }
  template <typename MasterUserSecretKmsKeyIdT = Aws::String>
  RestoreDBClusterFromS3Request& WithMasterUserSecretKmsKeyId(MasterUserSecretKmsKeyIdT&& value) {
    SetMasterUserSecretKmsKeyId(std::forward<MasterUserSecretKmsKeyIdT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The life cycle type for this DB cluster.</p>  <p>By default, this value
   * is set to <code>open-source-rds-extended-support</code>, which enrolls your DB
   * cluster into Amazon RDS Extended Support. At the end of standard support, you
   * can avoid charges for Extended Support by setting the value to
   * <code>open-source-rds-extended-support-disabled</code>. In this case, RDS
   * automatically upgrades your restored DB cluster to a higher engine version, if
   * the major engine version is past its end of standard support date.</p>
   * <p>You can use this setting to enroll your DB cluster into Amazon RDS Extended
   * Support. With RDS Extended Support, you can run the selected major engine
   * version on your DB cluster past the end of standard support for that engine
   * version. For more information, see the following sections:</p> <ul> <li>
   * <p>Amazon Aurora - <a
   * href="https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/extended-support.html">Amazon
   * RDS Extended Support with Amazon Aurora</a> in the <i>Amazon Aurora User
   * Guide</i> </p> </li> <li> <p>Amazon RDS - <a
   * href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/extended-support.html">Amazon
   * RDS Extended Support with Amazon RDS</a> in the <i>Amazon RDS User Guide</i>
   * </p> </li> </ul> <p>Valid for Cluster Type: Aurora DB clusters and Multi-AZ DB
   * clusters</p> <p>Valid Values: <code>open-source-rds-extended-support |
   * open-source-rds-extended-support-disabled</code> </p> <p>Default:
   * <code>open-source-rds-extended-support</code> </p>
   */
  inline const Aws::String& GetEngineLifecycleSupport() const { return m_engineLifecycleSupport; }
  inline bool EngineLifecycleSupportHasBeenSet() const { return m_engineLifecycleSupportHasBeenSet; }
  template <typename EngineLifecycleSupportT = Aws::String>
  void SetEngineLifecycleSupport(EngineLifecycleSupportT&& value) {
    m_engineLifecycleSupportHasBeenSet = true;
    m_engineLifecycleSupport = std::forward<EngineLifecycleSupportT>(value);
  }
  template <typename EngineLifecycleSupportT = Aws::String>
  RestoreDBClusterFromS3Request& WithEngineLifecycleSupport(EngineLifecycleSupportT&& value) {
    SetEngineLifecycleSupport(std::forward<EngineLifecycleSupportT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>Tags to assign to resources associated with the DB cluster.</p> <p>Valid
   * Values: </p> <ul> <li> <p> <code>cluster-auto-backup</code> - The DB cluster's
   * automated backup.</p> </li> </ul>
   */
  inline const Aws::Vector<TagSpecification>& GetTagSpecifications() const { return m_tagSpecifications; }
  inline bool TagSpecificationsHasBeenSet() const { return m_tagSpecificationsHasBeenSet; }
  template <typename TagSpecificationsT = Aws::Vector<TagSpecification>>
  void SetTagSpecifications(TagSpecificationsT&& value) {
    m_tagSpecificationsHasBeenSet = true;
    m_tagSpecifications = std::forward<TagSpecificationsT>(value);
  }
  template <typename TagSpecificationsT = Aws::Vector<TagSpecification>>
  RestoreDBClusterFromS3Request& WithTagSpecifications(TagSpecificationsT&& value) {
    SetTagSpecifications(std::forward<TagSpecificationsT>(value));
    return *this;
  }
  template <typename TagSpecificationsT = TagSpecification>
  RestoreDBClusterFromS3Request& AddTagSpecifications(TagSpecificationsT&& value) {
    m_tagSpecificationsHasBeenSet = true;
    m_tagSpecifications.emplace_back(std::forward<TagSpecificationsT>(value));
    return *this;
  }
  ///@}
 private:
  Aws::Vector<Aws::String> m_availabilityZones;

  int m_backupRetentionPeriod{0};

  Aws::String m_characterSetName;

  Aws::String m_databaseName;

  Aws::String m_dBClusterIdentifier;

  Aws::String m_dBClusterParameterGroupName;

  Aws::Vector<Aws::String> m_vpcSecurityGroupIds;

  Aws::String m_dBSubnetGroupName;

  Aws::String m_engine;

  Aws::String m_engineVersion;

  int m_port{0};

  Aws::String m_masterUsername;

  Aws::String m_masterUserPassword;

  Aws::String m_optionGroupName;

  Aws::String m_preferredBackupWindow;

  Aws::String m_preferredMaintenanceWindow;

  Aws::Vector<Tag> m_tags;

  bool m_storageEncrypted{false};

  Aws::String m_kmsKeyId;

  bool m_enableIAMDatabaseAuthentication{false};

  Aws::String m_sourceEngine;

  Aws::String m_sourceEngineVersion;

  Aws::String m_s3BucketName;

  Aws::String m_s3Prefix;

  Aws::String m_s3IngestionRoleArn;

  long long m_backtrackWindow{0};

  Aws::Vector<Aws::String> m_enableCloudwatchLogsExports;

  bool m_deletionProtection{false};

  bool m_copyTagsToSnapshot{false};

  Aws::String m_domain;

  Aws::String m_domainIAMRoleName;

  Aws::String m_storageType;

  Aws::String m_networkType;

  ServerlessV2ScalingConfiguration m_serverlessV2ScalingConfiguration;

  bool m_manageMasterUserPassword{false};

  Aws::String m_masterUserSecretKmsKeyId;

  Aws::String m_engineLifecycleSupport;

  Aws::Vector<TagSpecification> m_tagSpecifications;
  bool m_availabilityZonesHasBeenSet = false;
  bool m_backupRetentionPeriodHasBeenSet = false;
  bool m_characterSetNameHasBeenSet = false;
  bool m_databaseNameHasBeenSet = false;
  bool m_dBClusterIdentifierHasBeenSet = false;
  bool m_dBClusterParameterGroupNameHasBeenSet = false;
  bool m_vpcSecurityGroupIdsHasBeenSet = false;
  bool m_dBSubnetGroupNameHasBeenSet = false;
  bool m_engineHasBeenSet = false;
  bool m_engineVersionHasBeenSet = false;
  bool m_portHasBeenSet = false;
  bool m_masterUsernameHasBeenSet = false;
  bool m_masterUserPasswordHasBeenSet = false;
  bool m_optionGroupNameHasBeenSet = false;
  bool m_preferredBackupWindowHasBeenSet = false;
  bool m_preferredMaintenanceWindowHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_storageEncryptedHasBeenSet = false;
  bool m_kmsKeyIdHasBeenSet = false;
  bool m_enableIAMDatabaseAuthenticationHasBeenSet = false;
  bool m_sourceEngineHasBeenSet = false;
  bool m_sourceEngineVersionHasBeenSet = false;
  bool m_s3BucketNameHasBeenSet = false;
  bool m_s3PrefixHasBeenSet = false;
  bool m_s3IngestionRoleArnHasBeenSet = false;
  bool m_backtrackWindowHasBeenSet = false;
  bool m_enableCloudwatchLogsExportsHasBeenSet = false;
  bool m_deletionProtectionHasBeenSet = false;
  bool m_copyTagsToSnapshotHasBeenSet = false;
  bool m_domainHasBeenSet = false;
  bool m_domainIAMRoleNameHasBeenSet = false;
  bool m_storageTypeHasBeenSet = false;
  bool m_networkTypeHasBeenSet = false;
  bool m_serverlessV2ScalingConfigurationHasBeenSet = false;
  bool m_manageMasterUserPasswordHasBeenSet = false;
  bool m_masterUserSecretKmsKeyIdHasBeenSet = false;
  bool m_engineLifecycleSupportHasBeenSet = false;
  bool m_tagSpecificationsHasBeenSet = false;
};

}  // namespace Model
}  // namespace RDS
}  // namespace Aws
