/**
 * 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/neptune/NeptuneRequest.h>
#include <aws/neptune/Neptune_EXPORTS.h>
#include <aws/neptune/model/CloudwatchLogsExportConfiguration.h>
#include <aws/neptune/model/ServerlessV2ScalingConfiguration.h>

#include <utility>

namespace Aws {
namespace Neptune {
namespace Model {

/**
 */
class ModifyDBClusterRequest : public NeptuneRequest {
 public:
  AWS_NEPTUNE_API ModifyDBClusterRequest() = 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 "ModifyDBCluster"; }

  AWS_NEPTUNE_API Aws::String SerializePayload() const override;

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

 public:
  ///@{
  /**
   * <p>The DB cluster identifier for the cluster being modified. This parameter is
   * not case-sensitive.</p> <p>Constraints:</p> <ul> <li> <p>Must match the
   * identifier of an existing DBCluster.</p> </li> </ul>
   */
  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>
  ModifyDBClusterRequest& WithDBClusterIdentifier(DBClusterIdentifierT&& value) {
    SetDBClusterIdentifier(std::forward<DBClusterIdentifierT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The new DB cluster identifier for the DB cluster when renaming a DB cluster.
   * This value is stored as a lowercase string.</p> <p>Constraints:</p> <ul> <li>
   * <p>Must contain from 1 to 63 letters, numbers, or hyphens</p> </li> <li> <p>The
   * first character must be a letter</p> </li> <li> <p>Cannot end with a hyphen or
   * contain two consecutive hyphens</p> </li> </ul> <p>Example:
   * <code>my-cluster2</code> </p>
   */
  inline const Aws::String& GetNewDBClusterIdentifier() const { return m_newDBClusterIdentifier; }
  inline bool NewDBClusterIdentifierHasBeenSet() const { return m_newDBClusterIdentifierHasBeenSet; }
  template <typename NewDBClusterIdentifierT = Aws::String>
  void SetNewDBClusterIdentifier(NewDBClusterIdentifierT&& value) {
    m_newDBClusterIdentifierHasBeenSet = true;
    m_newDBClusterIdentifier = std::forward<NewDBClusterIdentifierT>(value);
  }
  template <typename NewDBClusterIdentifierT = Aws::String>
  ModifyDBClusterRequest& WithNewDBClusterIdentifier(NewDBClusterIdentifierT&& value) {
    SetNewDBClusterIdentifier(std::forward<NewDBClusterIdentifierT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>A value that specifies whether the modifications in this request and any
   * pending modifications are asynchronously applied as soon as possible, regardless
   * of the <code>PreferredMaintenanceWindow</code> setting for the DB cluster. If
   * this parameter is set to <code>false</code>, changes to the DB cluster are
   * applied during the next maintenance window.</p> <p>The
   * <code>ApplyImmediately</code> parameter only affects
   * <code>NewDBClusterIdentifier</code> values. If you set the
   * <code>ApplyImmediately</code> parameter value to false, then changes to
   * <code>NewDBClusterIdentifier</code> values are applied during the next
   * maintenance window. All other changes are applied immediately, regardless of the
   * value of the <code>ApplyImmediately</code> parameter.</p> <p>Default:
   * <code>false</code> </p>
   */
  inline bool GetApplyImmediately() const { return m_applyImmediately; }
  inline bool ApplyImmediatelyHasBeenSet() const { return m_applyImmediatelyHasBeenSet; }
  inline void SetApplyImmediately(bool value) {
    m_applyImmediatelyHasBeenSet = true;
    m_applyImmediately = value;
  }
  inline ModifyDBClusterRequest& WithApplyImmediately(bool value) {
    SetApplyImmediately(value);
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The number of days for which automated backups 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 ModifyDBClusterRequest& WithBackupRetentionPeriod(int value) {
    SetBackupRetentionPeriod(value);
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The name of the DB cluster parameter group to use for the DB cluster.</p>
   */
  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>
  ModifyDBClusterRequest& WithDBClusterParameterGroupName(DBClusterParameterGroupNameT&& value) {
    SetDBClusterParameterGroupName(std::forward<DBClusterParameterGroupNameT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>A list of VPC security groups that the DB cluster will belong to.</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>>
  ModifyDBClusterRequest& WithVpcSecurityGroupIds(VpcSecurityGroupIdsT&& value) {
    SetVpcSecurityGroupIds(std::forward<VpcSecurityGroupIdsT>(value));
    return *this;
  }
  template <typename VpcSecurityGroupIdsT = Aws::String>
  ModifyDBClusterRequest& AddVpcSecurityGroupIds(VpcSecurityGroupIdsT&& value) {
    m_vpcSecurityGroupIdsHasBeenSet = true;
    m_vpcSecurityGroupIds.emplace_back(std::forward<VpcSecurityGroupIdsT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The port number on which the DB cluster accepts connections.</p>
   * <p>Constraints: Value must be <code>1150-65535</code> </p> <p>Default: The same
   * port as the original DB cluster.</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 ModifyDBClusterRequest& WithPort(int value) {
    SetPort(value);
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>Not supported by Neptune.</p>
   */
  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>
  ModifyDBClusterRequest& WithMasterUserPassword(MasterUserPasswordT&& value) {
    SetMasterUserPassword(std::forward<MasterUserPasswordT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p> <i>Not supported by Neptune.</i> </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>
  ModifyDBClusterRequest& 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 Region.</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>
  ModifyDBClusterRequest& 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 Region, occurring on a random day of the week.</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>
  ModifyDBClusterRequest& WithPreferredMaintenanceWindow(PreferredMaintenanceWindowT&& value) {
    SetPreferredMaintenanceWindow(std::forward<PreferredMaintenanceWindowT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>True to enable mapping of Amazon Identity and Access Management (IAM)
   * accounts to database accounts, and otherwise false.</p> <p>Default:
   * <code>false</code> </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 ModifyDBClusterRequest& WithEnableIAMDatabaseAuthentication(bool value) {
    SetEnableIAMDatabaseAuthentication(value);
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The configuration setting for the log types to be enabled for export to
   * CloudWatch Logs for a specific DB cluster. See <a
   * href="https://docs.aws.amazon.com/neptune/latest/userguide/cloudwatch-logs.html#cloudwatch-logs-cli">Using
   * the CLI to publish Neptune audit logs to CloudWatch Logs</a>.</p>
   */
  inline const CloudwatchLogsExportConfiguration& GetCloudwatchLogsExportConfiguration() const {
    return m_cloudwatchLogsExportConfiguration;
  }
  inline bool CloudwatchLogsExportConfigurationHasBeenSet() const { return m_cloudwatchLogsExportConfigurationHasBeenSet; }
  template <typename CloudwatchLogsExportConfigurationT = CloudwatchLogsExportConfiguration>
  void SetCloudwatchLogsExportConfiguration(CloudwatchLogsExportConfigurationT&& value) {
    m_cloudwatchLogsExportConfigurationHasBeenSet = true;
    m_cloudwatchLogsExportConfiguration = std::forward<CloudwatchLogsExportConfigurationT>(value);
  }
  template <typename CloudwatchLogsExportConfigurationT = CloudwatchLogsExportConfiguration>
  ModifyDBClusterRequest& WithCloudwatchLogsExportConfiguration(CloudwatchLogsExportConfigurationT&& value) {
    SetCloudwatchLogsExportConfiguration(std::forward<CloudwatchLogsExportConfigurationT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The version number of the database engine to which you want to upgrade.
   * Changing this parameter results in an outage. The change is applied during the
   * next maintenance window unless the <code>ApplyImmediately</code> parameter is
   * set to true.</p> <p>For a list of valid engine versions, see <a
   * href="https://docs.aws.amazon.com/neptune/latest/userguide/engine-releases.html">Engine
   * Releases for Amazon Neptune</a>, or call <a>DescribeDBEngineVersions</a>.</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>
  ModifyDBClusterRequest& WithEngineVersion(EngineVersionT&& value) {
    SetEngineVersion(std::forward<EngineVersionT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>A value that indicates whether upgrades between different major versions are
   * allowed.</p> <p>Constraints: You must set the allow-major-version-upgrade flag
   * when providing an <code>EngineVersion</code> parameter that uses a different
   * major version than the DB cluster's current version.</p>
   */
  inline bool GetAllowMajorVersionUpgrade() const { return m_allowMajorVersionUpgrade; }
  inline bool AllowMajorVersionUpgradeHasBeenSet() const { return m_allowMajorVersionUpgradeHasBeenSet; }
  inline void SetAllowMajorVersionUpgrade(bool value) {
    m_allowMajorVersionUpgradeHasBeenSet = true;
    m_allowMajorVersionUpgrade = value;
  }
  inline ModifyDBClusterRequest& WithAllowMajorVersionUpgrade(bool value) {
    SetAllowMajorVersionUpgrade(value);
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The name of the DB parameter group to apply to all instances of the DB
   * cluster. </p>  <p>When you apply a parameter group using
   * <code>DBInstanceParameterGroupName</code>, parameter changes aren't applied
   * during the next maintenance window but instead are applied immediately.</p>
   *  <p>Default: The existing name setting</p> <p>Constraints:</p> <ul> <li>
   * <p>The DB parameter group must be in the same DB parameter group family as the
   * target DB cluster version.</p> </li> <li> <p>The
   * <code>DBInstanceParameterGroupName</code> parameter is only valid in combination
   * with the <code>AllowMajorVersionUpgrade</code> parameter.</p> </li> </ul>
   */
  inline const Aws::String& GetDBInstanceParameterGroupName() const { return m_dBInstanceParameterGroupName; }
  inline bool DBInstanceParameterGroupNameHasBeenSet() const { return m_dBInstanceParameterGroupNameHasBeenSet; }
  template <typename DBInstanceParameterGroupNameT = Aws::String>
  void SetDBInstanceParameterGroupName(DBInstanceParameterGroupNameT&& value) {
    m_dBInstanceParameterGroupNameHasBeenSet = true;
    m_dBInstanceParameterGroupName = std::forward<DBInstanceParameterGroupNameT>(value);
  }
  template <typename DBInstanceParameterGroupNameT = Aws::String>
  ModifyDBClusterRequest& WithDBInstanceParameterGroupName(DBInstanceParameterGroupNameT&& value) {
    SetDBInstanceParameterGroupName(std::forward<DBInstanceParameterGroupNameT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>A value that indicates whether the DB cluster has deletion protection
   * enabled. The database can't be deleted when deletion protection is enabled. By
   * default, deletion protection is disabled.</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 ModifyDBClusterRequest& WithDeletionProtection(bool value) {
    SetDeletionProtection(value);
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p> <i>If set to <code>true</code>, tags are copied to any snapshot of the DB
   * cluster that is created.</i> </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 ModifyDBClusterRequest& WithCopyTagsToSnapshot(bool value) {
    SetCopyTagsToSnapshot(value);
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>Contains the scaling configuration of a Neptune Serverless DB cluster.</p>
   * <p>For more information, see <a
   * href="https://docs.aws.amazon.com/neptune/latest/userguide/neptune-serverless-using.html">Using
   * Amazon Neptune Serverless</a> in the <i>Amazon Neptune User Guide</i>.</p>
   */
  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>
  ModifyDBClusterRequest& WithServerlessV2ScalingConfiguration(ServerlessV2ScalingConfigurationT&& value) {
    SetServerlessV2ScalingConfiguration(std::forward<ServerlessV2ScalingConfigurationT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The storage type to associate with the DB cluster.</p> <p>Valid Values:</p>
   * <ul> <li> <p> <b> <code>standard</code> </b>   –   ( <i>the default</i> )
   * Configures cost-effective database storage for applications with moderate to
   * small I/O usage.</p> </li> <li> <p> <b> <code>iopt1</code> </b>   –   Enables <a
   * href="https://docs.aws.amazon.com/neptune/latest/userguide/storage-types.html#provisioned-iops-storage">I/O-Optimized
   * storage</a> that's designed to meet the needs of I/O-intensive graph workloads
   * that require predictable pricing with low I/O latency and consistent I/O
   * throughput.</p> <p>Neptune I/O-Optimized storage is only available starting with
   * engine release 1.3.0.0.</p> </li> </ul>
   */
  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>
  ModifyDBClusterRequest& WithStorageType(StorageTypeT&& value) {
    SetStorageType(std::forward<StorageTypeT>(value));
    return *this;
  }
  ///@}
 private:
  Aws::String m_dBClusterIdentifier;

  Aws::String m_newDBClusterIdentifier;

  bool m_applyImmediately{false};

  int m_backupRetentionPeriod{0};

  Aws::String m_dBClusterParameterGroupName;

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

  int m_port{0};

  Aws::String m_masterUserPassword;

  Aws::String m_optionGroupName;

  Aws::String m_preferredBackupWindow;

  Aws::String m_preferredMaintenanceWindow;

  bool m_enableIAMDatabaseAuthentication{false};

  CloudwatchLogsExportConfiguration m_cloudwatchLogsExportConfiguration;

  Aws::String m_engineVersion;

  bool m_allowMajorVersionUpgrade{false};

  Aws::String m_dBInstanceParameterGroupName;

  bool m_deletionProtection{false};

  bool m_copyTagsToSnapshot{false};

  ServerlessV2ScalingConfiguration m_serverlessV2ScalingConfiguration;

  Aws::String m_storageType;
  bool m_dBClusterIdentifierHasBeenSet = false;
  bool m_newDBClusterIdentifierHasBeenSet = false;
  bool m_applyImmediatelyHasBeenSet = false;
  bool m_backupRetentionPeriodHasBeenSet = false;
  bool m_dBClusterParameterGroupNameHasBeenSet = false;
  bool m_vpcSecurityGroupIdsHasBeenSet = false;
  bool m_portHasBeenSet = false;
  bool m_masterUserPasswordHasBeenSet = false;
  bool m_optionGroupNameHasBeenSet = false;
  bool m_preferredBackupWindowHasBeenSet = false;
  bool m_preferredMaintenanceWindowHasBeenSet = false;
  bool m_enableIAMDatabaseAuthenticationHasBeenSet = false;
  bool m_cloudwatchLogsExportConfigurationHasBeenSet = false;
  bool m_engineVersionHasBeenSet = false;
  bool m_allowMajorVersionUpgradeHasBeenSet = false;
  bool m_dBInstanceParameterGroupNameHasBeenSet = false;
  bool m_deletionProtectionHasBeenSet = false;
  bool m_copyTagsToSnapshotHasBeenSet = false;
  bool m_serverlessV2ScalingConfigurationHasBeenSet = false;
  bool m_storageTypeHasBeenSet = false;
};

}  // namespace Model
}  // namespace Neptune
}  // namespace Aws
