/*******************************************************************************
* Copyright 2012-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use
* this file except in compliance with the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file.
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
* *****************************************************************************
*
* AWS Tools for Windows (TM) PowerShell (TM)
*
*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Management.Automation;
using System.Text;
using Amazon.PowerShell.Common;
using Amazon.Runtime;
using Amazon.RDS;
using Amazon.RDS.Model;
namespace Amazon.PowerShell.Cmdlets.RDS
{
/// <summary>
/// Creates a new DB cluster from a DB snapshot or DB cluster snapshot.
///
///
/// <para>
/// The target DB cluster is created from the source snapshot with a default configuration.
/// If you don't specify a security group, the new DB cluster is associated with the default
/// security group.
/// </para><note><para>
/// This action only restores the DB cluster, not the DB instances for that DB cluster.
/// You must invoke the <code>CreateDBInstance</code> action to create DB instances for
/// the restored DB cluster, specifying the identifier of the restored DB cluster in <code>DBClusterIdentifier</code>.
/// You can create DB instances only after the <code>RestoreDBClusterFromSnapshot</code>
/// action has completed and the DB cluster is available.
/// </para></note><para>
/// For more information on Amazon Aurora DB clusters, see <a href="https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html">
/// What is Amazon Aurora?</a> in the <i>Amazon Aurora User Guide</i>.
/// </para><para>
/// For more information on Multi-AZ DB clusters, see <a href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/multi-az-db-clusters-concepts.html">
/// Multi-AZ DB cluster deployments</a> in the <i>Amazon RDS User Guide.</i></para>
/// </summary>
[Cmdlet("Restore", "RDSDBClusterFromSnapshot", SupportsShouldProcess = true, ConfirmImpact = ConfirmImpact.Medium)]
[OutputType("Amazon.RDS.Model.DBCluster")]
[AWSCmdlet("Calls the Amazon Relational Database Service RestoreDBClusterFromSnapshot API operation.", Operation = new[] {"RestoreDBClusterFromSnapshot"}, SelectReturnType = typeof(Amazon.RDS.Model.RestoreDBClusterFromSnapshotResponse))]
[AWSCmdletOutput("Amazon.RDS.Model.DBCluster or Amazon.RDS.Model.RestoreDBClusterFromSnapshotResponse",
"This cmdlet returns an Amazon.RDS.Model.DBCluster object.",
"The service call response (type Amazon.RDS.Model.RestoreDBClusterFromSnapshotResponse) can also be referenced from properties attached to the cmdlet entry in the $AWSHistory stack."
)]
public partial class RestoreRDSDBClusterFromSnapshotCmdlet : AmazonRDSClientCmdlet, IExecutor
{
#region Parameter ScalingConfiguration_AutoPause
/// <summary>
/// <para>
/// <para>A value that indicates whether to allow or disallow automatic pause for an Aurora
/// DB cluster in <code>serverless</code> DB engine mode. A DB cluster can be paused only
/// when it's idle (it has no connections).</para><note><para>If a DB cluster is paused for more than seven days, the DB cluster might be backed
/// up with a snapshot. In this case, the DB cluster is restored when there is a request
/// to connect to it.</para></note>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.Boolean? ScalingConfiguration_AutoPause { get; set; }
#endregion
#region Parameter AvailabilityZone
/// <summary>
/// <para>
/// <para>Provides the list of Availability Zones (AZs) where instances in the restored DB cluster
/// can be created.</para><para>Valid for: Aurora DB clusters only</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("AvailabilityZones")]
public System.String[] AvailabilityZone { get; set; }
#endregion
#region Parameter BacktrackWindow
/// <summary>
/// <para>
/// <para>The target backtrack window, in seconds. To disable backtracking, set this value to
/// 0.</para><note><para>Currently, Backtrack is only supported for Aurora MySQL DB clusters.</para></note><para>Default: 0</para><para>Constraints:</para><ul><li><para>If specified, this value must be set to a number from 0 to 259,200 (72 hours).</para></li></ul><para>Valid for: Aurora DB clusters only</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.Int64? BacktrackWindow { get; set; }
#endregion
#region Parameter CopyTagsToSnapshot
/// <summary>
/// <para>
/// <para>A value that indicates whether to copy all tags from the restored DB cluster to snapshots
/// of the restored DB cluster. The default is not to copy them.</para><para>Valid for: Aurora DB clusters and Multi-AZ DB clusters</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.Boolean? CopyTagsToSnapshot { get; set; }
#endregion
#region Parameter DatabaseName
/// <summary>
/// <para>
/// <para>The database name for the restored DB cluster.</para><para>Valid for: Aurora DB clusters and Multi-AZ DB clusters</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String DatabaseName { get; set; }
#endregion
#region Parameter DBClusterIdentifier
/// <summary>
/// <para>
/// <para>The name of the DB cluster to create from the DB snapshot or DB cluster snapshot.
/// This parameter isn't case-sensitive.</para><para>Constraints:</para><ul><li><para>Must contain from 1 to 63 letters, numbers, or hyphens</para></li><li><para>First character must be a letter</para></li><li><para>Can't end with a hyphen or contain two consecutive hyphens</para></li></ul><para>Example: <code>my-snapshot-id</code></para><para>Valid for: Aurora DB clusters and Multi-AZ DB clusters</para>
/// </para>
/// </summary>
#if !MODULAR
[System.Management.Automation.Parameter(Position = 0, ValueFromPipelineByPropertyName = true, ValueFromPipeline = true)]
#else
[System.Management.Automation.Parameter(Position = 0, ValueFromPipelineByPropertyName = true, ValueFromPipeline = true, Mandatory = true)]
[System.Management.Automation.AllowEmptyString]
[System.Management.Automation.AllowNull]
#endif
[Amazon.PowerShell.Common.AWSRequiredParameter]
public System.String DBClusterIdentifier { get; set; }
#endregion
#region Parameter DBClusterInstanceClass
/// <summary>
/// <para>
/// <para>The compute and memory capacity of the each DB instance in the Multi-AZ DB cluster,
/// for example db.m6gd.xlarge. Not all DB instance classes are available in all Amazon
/// Web Services Regions, or for all database engines.</para><para>For the full list of DB instance classes, and availability for your engine, see <a href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.DBInstanceClass.html">DB
/// Instance Class</a> in the <i>Amazon RDS User Guide.</i></para><para>Valid for: Multi-AZ DB clusters only</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String DBClusterInstanceClass { get; set; }
#endregion
#region Parameter DBClusterParameterGroupName
/// <summary>
/// <para>
/// <para>The name of the DB cluster parameter group to associate with this DB cluster. If this
/// argument is omitted, the default DB cluster parameter group for the specified engine
/// is used.</para><para>Constraints:</para><ul><li><para>If supplied, must match the name of an existing default DB cluster parameter group.</para></li><li><para>Must be 1 to 255 letters, numbers, or hyphens.</para></li><li><para>First character must be a letter.</para></li><li><para>Can't end with a hyphen or contain two consecutive hyphens.</para></li></ul><para>Valid for: Aurora DB clusters and Multi-AZ DB clusters</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String DBClusterParameterGroupName { get; set; }
#endregion
#region Parameter DBSubnetGroupName
/// <summary>
/// <para>
/// <para>The name of the DB subnet group to use for the new DB cluster.</para><para>Constraints: If supplied, must match the name of an existing DB subnet group.</para><para>Example: <code>mydbsubnetgroup</code></para><para>Valid for: Aurora DB clusters and Multi-AZ DB clusters</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String DBSubnetGroupName { get; set; }
#endregion
#region Parameter DeletionProtection
/// <summary>
/// <para>
/// <para>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 isn't enabled.</para><para>Valid for: Aurora DB clusters and Multi-AZ DB clusters</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.Boolean? DeletionProtection { get; set; }
#endregion
#region Parameter Domain
/// <summary>
/// <para>
/// <para>Specify the Active Directory directory ID to restore the DB cluster in. The domain
/// must be created prior to this operation. Currently, only MySQL, Microsoft SQL Server,
/// Oracle, and PostgreSQL DB instances can be created in an Active Directory Domain.</para><para>For more information, see <a href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/kerberos-authentication.html">
/// Kerberos Authentication</a> in the <i>Amazon RDS User Guide</i>.</para><para>Valid for: Aurora DB clusters only</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String Domain { get; set; }
#endregion
#region Parameter DomainIAMRoleName
/// <summary>
/// <para>
/// <para>Specify the name of the IAM role to be used when making API calls to the Directory
/// Service.</para><para>Valid for: Aurora DB clusters only</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String DomainIAMRoleName { get; set; }
#endregion
#region Parameter EnableCloudwatchLogsExport
/// <summary>
/// <para>
/// <para>The list of logs that the restored DB cluster is to export to Amazon CloudWatch Logs.
/// The values in the list depend on the DB engine being used.</para><para><b>RDS for MySQL</b></para><para>Possible values are <code>error</code>, <code>general</code>, and <code>slowquery</code>.</para><para><b>RDS for PostgreSQL</b></para><para>Possible values are <code>postgresql</code> and <code>upgrade</code>.</para><para><b>Aurora MySQL</b></para><para>Possible values are <code>audit</code>, <code>error</code>, <code>general</code>,
/// and <code>slowquery</code>.</para><para><b>Aurora PostgreSQL</b></para><para>Possible value is <code>postgresql</code>.</para><para>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>.</para><para>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>.</para><para>Valid for: Aurora DB clusters and Multi-AZ DB clusters</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("EnableCloudwatchLogsExports")]
public System.String[] EnableCloudwatchLogsExport { get; set; }
#endregion
#region Parameter EnableIAMDatabaseAuthentication
/// <summary>
/// <para>
/// <para>A value that indicates whether to enable mapping of Amazon Web Services Identity and
/// Access Management (IAM) accounts to database accounts. By default, mapping isn't enabled.</para><para>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>.</para><para>Valid for: Aurora DB clusters only</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.Boolean? EnableIAMDatabaseAuthentication { get; set; }
#endregion
#region Parameter Engine
/// <summary>
/// <para>
/// <para>The database engine to use for the new DB cluster.</para><para>Default: The same as source</para><para>Constraint: Must be compatible with the engine of the source</para><para>Valid for: Aurora DB clusters and Multi-AZ DB clusters</para>
/// </para>
/// </summary>
#if !MODULAR
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
#else
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true, Mandatory = true)]
[System.Management.Automation.AllowEmptyString]
[System.Management.Automation.AllowNull]
#endif
[Amazon.PowerShell.Common.AWSRequiredParameter]
public System.String Engine { get; set; }
#endregion
#region Parameter EngineMode
/// <summary>
/// <para>
/// <para>The DB engine mode of the DB cluster, either <code>provisioned</code> or <code>serverless</code>.</para><para>For more information, see <a href="https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBCluster.html">
/// CreateDBCluster</a>.</para><para>Valid for: Aurora DB clusters only</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String EngineMode { get; set; }
#endregion
#region Parameter EngineVersion
/// <summary>
/// <para>
/// <para>The version of the database engine to use for the new DB cluster. If you don't specify
/// an engine version, the default version for the database engine in the Amazon Web Services
/// Region is used.</para><para>To list all of the available engine versions for Aurora MySQL, use the following command:</para><para><code>aws rds describe-db-engine-versions --engine aurora-mysql --query "DBEngineVersions[].EngineVersion"</code></para><para>To list all of the available engine versions for Aurora PostgreSQL, use the following
/// command:</para><para><code>aws rds describe-db-engine-versions --engine aurora-postgresql --query "DBEngineVersions[].EngineVersion"</code></para><para>To list all of the available engine versions for RDS for MySQL, use the following
/// command:</para><para><code>aws rds describe-db-engine-versions --engine mysql --query "DBEngineVersions[].EngineVersion"</code></para><para>To list all of the available engine versions for RDS for PostgreSQL, use the following
/// command:</para><para><code>aws rds describe-db-engine-versions --engine postgres --query "DBEngineVersions[].EngineVersion"</code></para><para><b>Aurora MySQL</b></para><para>See <a href="https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraMySQL.Updates.html">Database
/// engine updates for Amazon Aurora MySQL</a> in the <i>Amazon Aurora User Guide</i>.</para><para><b>Aurora PostgreSQL</b></para><para>See <a href="https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraPostgreSQL.Updates.20180305.html">Amazon
/// Aurora PostgreSQL releases and engine versions</a> in the <i>Amazon Aurora User Guide</i>.</para><para><b>MySQL</b></para><para>See <a href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_MySQL.html#MySQL.Concepts.VersionMgmt">Amazon
/// RDS for MySQL</a> in the <i>Amazon RDS User Guide.</i></para><para><b>PostgreSQL</b></para><para>See <a href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_PostgreSQL.html#PostgreSQL.Concepts">Amazon
/// RDS for PostgreSQL versions and extensions</a> in the <i>Amazon RDS User Guide.</i></para><para>Valid for: Aurora DB clusters and Multi-AZ DB clusters</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String EngineVersion { get; set; }
#endregion
#region Parameter Iops
/// <summary>
/// <para>
/// <para>The amount of Provisioned IOPS (input/output operations per second) to be initially
/// allocated for each DB instance in the Multi-AZ DB cluster.</para><para>For information about valid IOPS values, see <a href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Storage.html#USER_PIOPS">Amazon
/// RDS Provisioned IOPS storage</a> in the <i>Amazon RDS User Guide</i>.</para><para>Constraints: Must be a multiple between .5 and 50 of the storage amount for the DB
/// instance.</para><para>Valid for: Aurora DB clusters and Multi-AZ DB clusters</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.Int32? Iops { get; set; }
#endregion
#region Parameter KmsKeyId
/// <summary>
/// <para>
/// <para>The Amazon Web Services KMS key identifier to use when restoring an encrypted DB cluster
/// from a DB snapshot or DB cluster snapshot.</para><para>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.</para><para>When you don't specify a value for the <code>KmsKeyId</code> parameter, then the following
/// occurs:</para><ul><li><para>If the DB snapshot or DB cluster snapshot in <code>SnapshotIdentifier</code> is encrypted,
/// then the restored DB cluster is encrypted using the KMS key that was used to encrypt
/// the DB snapshot or DB cluster snapshot.</para></li><li><para>If the DB snapshot or DB cluster snapshot in <code>SnapshotIdentifier</code> isn't
/// encrypted, then the restored DB cluster isn't encrypted.</para></li></ul><para>Valid for: Aurora DB clusters and Multi-AZ DB clusters</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String KmsKeyId { get; set; }
#endregion
#region Parameter ScalingConfiguration_MaxCapacity
/// <summary>
/// <para>
/// <para>The maximum capacity for an Aurora DB cluster in <code>serverless</code> DB engine
/// mode.</para><para>For Aurora MySQL, valid capacity values are <code>1</code>, <code>2</code>, <code>4</code>,
/// <code>8</code>, <code>16</code>, <code>32</code>, <code>64</code>, <code>128</code>,
/// and <code>256</code>.</para><para>For Aurora PostgreSQL, valid capacity values are <code>2</code>, <code>4</code>, <code>8</code>,
/// <code>16</code>, <code>32</code>, <code>64</code>, <code>192</code>, and <code>384</code>.</para><para>The maximum capacity must be greater than or equal to the minimum capacity.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.Int32? ScalingConfiguration_MaxCapacity { get; set; }
#endregion
#region Parameter ServerlessV2ScalingConfiguration_MaxCapacity
/// <summary>
/// <para>
/// <para>The maximum number of Aurora capacity units (ACUs) for a DB instance in an Aurora
/// Serverless v2 cluster. You can specify ACU values in half-step increments, such as
/// 40, 40.5, 41, and so on. The largest value that you can use is 128.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.Double? ServerlessV2ScalingConfiguration_MaxCapacity { get; set; }
#endregion
#region Parameter ScalingConfiguration_MinCapacity
/// <summary>
/// <para>
/// <para>The minimum capacity for an Aurora DB cluster in <code>serverless</code> DB engine
/// mode.</para><para>For Aurora MySQL, valid capacity values are <code>1</code>, <code>2</code>, <code>4</code>,
/// <code>8</code>, <code>16</code>, <code>32</code>, <code>64</code>, <code>128</code>,
/// and <code>256</code>.</para><para>For Aurora PostgreSQL, valid capacity values are <code>2</code>, <code>4</code>, <code>8</code>,
/// <code>16</code>, <code>32</code>, <code>64</code>, <code>192</code>, and <code>384</code>.</para><para>The minimum capacity must be less than or equal to the maximum capacity.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.Int32? ScalingConfiguration_MinCapacity { get; set; }
#endregion
#region Parameter ServerlessV2ScalingConfiguration_MinCapacity
/// <summary>
/// <para>
/// <para>The minimum number of Aurora capacity units (ACUs) for a DB instance in an Aurora
/// Serverless v2 cluster. You can specify ACU values in half-step increments, such as
/// 8, 8.5, 9, and so on. The smallest value that you can use is 0.5.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.Double? ServerlessV2ScalingConfiguration_MinCapacity { get; set; }
#endregion
#region Parameter NetworkType
/// <summary>
/// <para>
/// <para>The network type of the DB cluster.</para><para>Valid values:</para><ul><li><para><code>IPV4</code></para></li><li><para><code>DUAL</code></para></li></ul><para>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>).</para><para>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></para><para>Valid for: Aurora DB clusters only</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String NetworkType { get; set; }
#endregion
#region Parameter OptionGroupName
/// <summary>
/// <para>
/// <para>The name of the option group to use for the restored DB cluster.</para><para>DB clusters are associated with a default option group that can't be modified.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String OptionGroupName { get; set; }
#endregion
#region Parameter Port
/// <summary>
/// <para>
/// <para>The port number on which the new DB cluster accepts connections.</para><para>Constraints: This value must be <code>1150-65535</code></para><para>Default: The same port as the original DB cluster.</para><para>Valid for: Aurora DB clusters and Multi-AZ DB clusters</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.Int32? Port { get; set; }
#endregion
#region Parameter PubliclyAccessible
/// <summary>
/// <para>
/// <para>A value that indicates whether the DB cluster is publicly accessible.</para><para>When the DB cluster is publicly accessible, its Domain Name System (DNS) endpoint
/// resolves to the private IP address from within the DB cluster's virtual private cloud
/// (VPC). It resolves to the public IP address from outside of the DB cluster's VPC.
/// Access to the DB cluster is ultimately controlled by the security group it uses. That
/// public access is not permitted if the security group assigned to the DB cluster doesn't
/// permit it.</para><para>When the DB cluster isn't publicly accessible, it is an internal DB cluster with a
/// DNS name that resolves to a private IP address.</para><para>Default: The default behavior varies depending on whether <code>DBSubnetGroupName</code>
/// is specified.</para><para>If <code>DBSubnetGroupName</code> isn't specified, and <code>PubliclyAccessible</code>
/// isn't specified, the following applies:</para><ul><li><para>If the default VPC in the target Region doesn’t have an internet gateway attached
/// to it, the DB cluster is private.</para></li><li><para>If the default VPC in the target Region has an internet gateway attached to it, the
/// DB cluster is public.</para></li></ul><para>If <code>DBSubnetGroupName</code> is specified, and <code>PubliclyAccessible</code>
/// isn't specified, the following applies:</para><ul><li><para>If the subnets are part of a VPC that doesn’t have an internet gateway attached to
/// it, the DB cluster is private.</para></li><li><para>If the subnets are part of a VPC that has an internet gateway attached to it, the
/// DB cluster is public.</para></li></ul><para>Valid for: Aurora DB clusters and Multi-AZ DB clusters</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.Boolean? PubliclyAccessible { get; set; }
#endregion
#region Parameter ScalingConfiguration_SecondsBeforeTimeout
/// <summary>
/// <para>
/// <para>The amount of time, in seconds, that Aurora Serverless v1 tries to find a scaling
/// point to perform seamless scaling before enforcing the timeout action. The default
/// is 300.</para><para>Specify a value between 60 and 600 seconds.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.Int32? ScalingConfiguration_SecondsBeforeTimeout { get; set; }
#endregion
#region Parameter ScalingConfiguration_SecondsUntilAutoPause
/// <summary>
/// <para>
/// <para>The time, in seconds, before an Aurora DB cluster in <code>serverless</code> mode
/// is paused.</para><para>Specify a value between 300 and 86,400 seconds.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.Int32? ScalingConfiguration_SecondsUntilAutoPause { get; set; }
#endregion
#region Parameter SnapshotIdentifier
/// <summary>
/// <para>
/// <para>The identifier for the DB snapshot or DB cluster snapshot to restore from.</para><para>You can use either the name or the Amazon Resource Name (ARN) to specify a DB cluster
/// snapshot. However, you can use only the ARN to specify a DB snapshot.</para><para>Constraints:</para><ul><li><para>Must match the identifier of an existing Snapshot.</para></li></ul><para>Valid for: Aurora DB clusters and Multi-AZ DB clusters</para>
/// </para>
/// </summary>
#if !MODULAR
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
#else
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true, Mandatory = true)]
[System.Management.Automation.AllowEmptyString]
[System.Management.Automation.AllowNull]
#endif
[Amazon.PowerShell.Common.AWSRequiredParameter]
public System.String SnapshotIdentifier { get; set; }
#endregion
#region Parameter StorageType
/// <summary>
/// <para>
/// <para>Specifies the storage type to be associated with the DB cluster.</para><para>When specified for a Multi-AZ DB cluster, a value for the <code>Iops</code> parameter
/// is required.</para><para>Valid values: <code>aurora</code>, <code>aurora-iopt1</code> (Aurora DB clusters);
/// <code>io1</code> (Multi-AZ DB clusters)</para><para>Default: <code>aurora</code> (Aurora DB clusters); <code>io1</code> (Multi-AZ DB clusters)</para><para>Valid for: Aurora DB clusters and Multi-AZ DB clusters</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String StorageType { get; set; }
#endregion
#region Parameter Tag
/// <summary>
/// <para>
/// <para>The tags to be assigned to the restored DB cluster.</para><para>Valid for: Aurora DB clusters and Multi-AZ DB clusters</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("Tags")]
public Amazon.RDS.Model.Tag[] Tag { get; set; }
#endregion
#region Parameter ScalingConfiguration_TimeoutAction
/// <summary>
/// <para>
/// <para>The action to take when the timeout is reached, either <code>ForceApplyCapacityChange</code>
/// or <code>RollbackCapacityChange</code>.</para><para><code>ForceApplyCapacityChange</code> sets the capacity to the specified value as
/// soon as possible.</para><para><code>RollbackCapacityChange</code>, the default, ignores the capacity change if
/// a scaling point isn't found in the timeout period.</para><important><para>If you specify <code>ForceApplyCapacityChange</code>, connections that prevent Aurora
/// Serverless v1 from finding a scaling point might be dropped.</para></important><para>For more information, see <a href="https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-serverless.how-it-works.html#aurora-serverless.how-it-works.auto-scaling">
/// Autoscaling for Aurora Serverless v1</a> in the <i>Amazon Aurora User Guide</i>.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String ScalingConfiguration_TimeoutAction { get; set; }
#endregion
#region Parameter VpcSecurityGroupId
/// <summary>
/// <para>
/// <para>A list of VPC security groups that the new DB cluster will belong to.</para><para>Valid for: Aurora DB clusters and Multi-AZ DB clusters</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("VpcSecurityGroupIds")]
public System.String[] VpcSecurityGroupId { get; set; }
#endregion
#region Parameter Select
/// <summary>
/// Use the -Select parameter to control the cmdlet output. The default value is 'DBCluster'.
/// Specifying -Select '*' will result in the cmdlet returning the whole service response (Amazon.RDS.Model.RestoreDBClusterFromSnapshotResponse).
/// Specifying the name of a property of type Amazon.RDS.Model.RestoreDBClusterFromSnapshotResponse will result in that property being returned.
/// Specifying -Select '^ParameterName' will result in the cmdlet returning the selected cmdlet parameter value.
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public string Select { get; set; } = "DBCluster";
#endregion
#region Parameter PassThru
/// <summary>
/// Changes the cmdlet behavior to return the value passed to the DBClusterIdentifier parameter.
/// The -PassThru parameter is deprecated, use -Select '^DBClusterIdentifier' instead. This parameter will be removed in a future version.
/// </summary>
[System.Obsolete("The -PassThru parameter is deprecated, use -Select '^DBClusterIdentifier' instead. This parameter will be removed in a future version.")]
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public SwitchParameter PassThru { get; set; }
#endregion
#region Parameter Force
/// <summary>
/// This parameter overrides confirmation prompts to force
/// the cmdlet to continue its operation. This parameter should always
/// be used with caution.
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public SwitchParameter Force { get; set; }
#endregion
protected override void ProcessRecord()
{
this._AWSSignerType = "v4";
base.ProcessRecord();
var resourceIdentifiersText = FormatParameterValuesForConfirmationMsg(nameof(this.DBClusterIdentifier), MyInvocation.BoundParameters);
if (!ConfirmShouldProceed(this.Force.IsPresent, resourceIdentifiersText, "Restore-RDSDBClusterFromSnapshot (RestoreDBClusterFromSnapshot)"))
{
return;
}
var context = new CmdletContext();
// allow for manipulation of parameters prior to loading into context
PreExecutionContextLoad(context);
#pragma warning disable CS0618, CS0612 //A class member was marked with the Obsolete attribute
if (ParameterWasBound(nameof(this.Select)))
{
context.Select = CreateSelectDelegate<Amazon.RDS.Model.RestoreDBClusterFromSnapshotResponse, RestoreRDSDBClusterFromSnapshotCmdlet>(Select) ??
throw new System.ArgumentException("Invalid value for -Select parameter.", nameof(this.Select));
if (this.PassThru.IsPresent)
{
throw new System.ArgumentException("-PassThru cannot be used when -Select is specified.", nameof(this.Select));
}
}
else if (this.PassThru.IsPresent)
{
context.Select = (response, cmdlet) => this.DBClusterIdentifier;
}
#pragma warning restore CS0618, CS0612 //A class member was marked with the Obsolete attribute
if (this.AvailabilityZone != null)
{
context.AvailabilityZone = new List<System.String>(this.AvailabilityZone);
}
context.BacktrackWindow = this.BacktrackWindow;
context.CopyTagsToSnapshot = this.CopyTagsToSnapshot;
context.DatabaseName = this.DatabaseName;
context.DBClusterIdentifier = this.DBClusterIdentifier;
#if MODULAR
if (this.DBClusterIdentifier == null && ParameterWasBound(nameof(this.DBClusterIdentifier)))
{
WriteWarning("You are passing $null as a value for parameter DBClusterIdentifier which is marked as required. In case you believe this parameter was incorrectly marked as required, report this by opening an issue at https://github.com/aws/aws-tools-for-powershell/issues.");
}
#endif
context.DBClusterInstanceClass = this.DBClusterInstanceClass;
context.DBClusterParameterGroupName = this.DBClusterParameterGroupName;
context.DBSubnetGroupName = this.DBSubnetGroupName;
context.DeletionProtection = this.DeletionProtection;
context.Domain = this.Domain;
context.DomainIAMRoleName = this.DomainIAMRoleName;
if (this.EnableCloudwatchLogsExport != null)
{
context.EnableCloudwatchLogsExport = new List<System.String>(this.EnableCloudwatchLogsExport);
}
context.EnableIAMDatabaseAuthentication = this.EnableIAMDatabaseAuthentication;
context.Engine = this.Engine;
#if MODULAR
if (this.Engine == null && ParameterWasBound(nameof(this.Engine)))
{
WriteWarning("You are passing $null as a value for parameter Engine which is marked as required. In case you believe this parameter was incorrectly marked as required, report this by opening an issue at https://github.com/aws/aws-tools-for-powershell/issues.");
}
#endif
context.EngineMode = this.EngineMode;
context.EngineVersion = this.EngineVersion;
context.Iops = this.Iops;
context.KmsKeyId = this.KmsKeyId;
context.NetworkType = this.NetworkType;
context.OptionGroupName = this.OptionGroupName;
context.Port = this.Port;
context.PubliclyAccessible = this.PubliclyAccessible;
context.ScalingConfiguration_AutoPause = this.ScalingConfiguration_AutoPause;
context.ScalingConfiguration_MaxCapacity = this.ScalingConfiguration_MaxCapacity;
context.ScalingConfiguration_MinCapacity = this.ScalingConfiguration_MinCapacity;
context.ScalingConfiguration_SecondsBeforeTimeout = this.ScalingConfiguration_SecondsBeforeTimeout;
context.ScalingConfiguration_SecondsUntilAutoPause = this.ScalingConfiguration_SecondsUntilAutoPause;
context.ScalingConfiguration_TimeoutAction = this.ScalingConfiguration_TimeoutAction;
context.ServerlessV2ScalingConfiguration_MaxCapacity = this.ServerlessV2ScalingConfiguration_MaxCapacity;
context.ServerlessV2ScalingConfiguration_MinCapacity = this.ServerlessV2ScalingConfiguration_MinCapacity;
context.SnapshotIdentifier = this.SnapshotIdentifier;
#if MODULAR
if (this.SnapshotIdentifier == null && ParameterWasBound(nameof(this.SnapshotIdentifier)))
{
WriteWarning("You are passing $null as a value for parameter SnapshotIdentifier which is marked as required. In case you believe this parameter was incorrectly marked as required, report this by opening an issue at https://github.com/aws/aws-tools-for-powershell/issues.");
}
#endif
context.StorageType = this.StorageType;
if (this.Tag != null)
{
context.Tag = new List<Amazon.RDS.Model.Tag>(this.Tag);
}
if (this.VpcSecurityGroupId != null)
{
context.VpcSecurityGroupId = new List<System.String>(this.VpcSecurityGroupId);
}
// allow further manipulation of loaded context prior to processing
PostExecutionContextLoad(context);
var output = Execute(context) as CmdletOutput;
ProcessOutput(output);
}
#region IExecutor Members
public object Execute(ExecutorContext context)
{
var cmdletContext = context as CmdletContext;
// create request
var request = new Amazon.RDS.Model.RestoreDBClusterFromSnapshotRequest();
if (cmdletContext.AvailabilityZone != null)
{
request.AvailabilityZones = cmdletContext.AvailabilityZone;
}
if (cmdletContext.BacktrackWindow != null)
{
request.BacktrackWindow = cmdletContext.BacktrackWindow.Value;
}
if (cmdletContext.CopyTagsToSnapshot != null)
{
request.CopyTagsToSnapshot = cmdletContext.CopyTagsToSnapshot.Value;
}
if (cmdletContext.DatabaseName != null)
{
request.DatabaseName = cmdletContext.DatabaseName;
}
if (cmdletContext.DBClusterIdentifier != null)
{
request.DBClusterIdentifier = cmdletContext.DBClusterIdentifier;
}
if (cmdletContext.DBClusterInstanceClass != null)
{
request.DBClusterInstanceClass = cmdletContext.DBClusterInstanceClass;
}
if (cmdletContext.DBClusterParameterGroupName != null)
{
request.DBClusterParameterGroupName = cmdletContext.DBClusterParameterGroupName;
}
if (cmdletContext.DBSubnetGroupName != null)
{
request.DBSubnetGroupName = cmdletContext.DBSubnetGroupName;
}
if (cmdletContext.DeletionProtection != null)
{
request.DeletionProtection = cmdletContext.DeletionProtection.Value;
}
if (cmdletContext.Domain != null)
{
request.Domain = cmdletContext.Domain;
}
if (cmdletContext.DomainIAMRoleName != null)
{
request.DomainIAMRoleName = cmdletContext.DomainIAMRoleName;
}
if (cmdletContext.EnableCloudwatchLogsExport != null)
{
request.EnableCloudwatchLogsExports = cmdletContext.EnableCloudwatchLogsExport;
}
if (cmdletContext.EnableIAMDatabaseAuthentication != null)
{
request.EnableIAMDatabaseAuthentication = cmdletContext.EnableIAMDatabaseAuthentication.Value;
}
if (cmdletContext.Engine != null)
{
request.Engine = cmdletContext.Engine;
}
if (cmdletContext.EngineMode != null)
{
request.EngineMode = cmdletContext.EngineMode;
}
if (cmdletContext.EngineVersion != null)
{
request.EngineVersion = cmdletContext.EngineVersion;
}
if (cmdletContext.Iops != null)
{
request.Iops = cmdletContext.Iops.Value;
}
if (cmdletContext.KmsKeyId != null)
{
request.KmsKeyId = cmdletContext.KmsKeyId;
}
if (cmdletContext.NetworkType != null)
{
request.NetworkType = cmdletContext.NetworkType;
}
if (cmdletContext.OptionGroupName != null)
{
request.OptionGroupName = cmdletContext.OptionGroupName;
}
if (cmdletContext.Port != null)
{
request.Port = cmdletContext.Port.Value;
}
if (cmdletContext.PubliclyAccessible != null)
{
request.PubliclyAccessible = cmdletContext.PubliclyAccessible.Value;
}
// populate ScalingConfiguration
var requestScalingConfigurationIsNull = true;
request.ScalingConfiguration = new Amazon.RDS.Model.ScalingConfiguration();
System.Boolean? requestScalingConfiguration_scalingConfiguration_AutoPause = null;
if (cmdletContext.ScalingConfiguration_AutoPause != null)
{
requestScalingConfiguration_scalingConfiguration_AutoPause = cmdletContext.ScalingConfiguration_AutoPause.Value;
}
if (requestScalingConfiguration_scalingConfiguration_AutoPause != null)
{
request.ScalingConfiguration.AutoPause = requestScalingConfiguration_scalingConfiguration_AutoPause.Value;
requestScalingConfigurationIsNull = false;
}
System.Int32? requestScalingConfiguration_scalingConfiguration_MaxCapacity = null;
if (cmdletContext.ScalingConfiguration_MaxCapacity != null)
{
requestScalingConfiguration_scalingConfiguration_MaxCapacity = cmdletContext.ScalingConfiguration_MaxCapacity.Value;
}
if (requestScalingConfiguration_scalingConfiguration_MaxCapacity != null)
{
request.ScalingConfiguration.MaxCapacity = requestScalingConfiguration_scalingConfiguration_MaxCapacity.Value;
requestScalingConfigurationIsNull = false;
}
System.Int32? requestScalingConfiguration_scalingConfiguration_MinCapacity = null;
if (cmdletContext.ScalingConfiguration_MinCapacity != null)
{
requestScalingConfiguration_scalingConfiguration_MinCapacity = cmdletContext.ScalingConfiguration_MinCapacity.Value;
}
if (requestScalingConfiguration_scalingConfiguration_MinCapacity != null)
{
request.ScalingConfiguration.MinCapacity = requestScalingConfiguration_scalingConfiguration_MinCapacity.Value;
requestScalingConfigurationIsNull = false;
}
System.Int32? requestScalingConfiguration_scalingConfiguration_SecondsBeforeTimeout = null;
if (cmdletContext.ScalingConfiguration_SecondsBeforeTimeout != null)
{
requestScalingConfiguration_scalingConfiguration_SecondsBeforeTimeout = cmdletContext.ScalingConfiguration_SecondsBeforeTimeout.Value;
}
if (requestScalingConfiguration_scalingConfiguration_SecondsBeforeTimeout != null)
{
request.ScalingConfiguration.SecondsBeforeTimeout = requestScalingConfiguration_scalingConfiguration_SecondsBeforeTimeout.Value;
requestScalingConfigurationIsNull = false;
}
System.Int32? requestScalingConfiguration_scalingConfiguration_SecondsUntilAutoPause = null;
if (cmdletContext.ScalingConfiguration_SecondsUntilAutoPause != null)
{
requestScalingConfiguration_scalingConfiguration_SecondsUntilAutoPause = cmdletContext.ScalingConfiguration_SecondsUntilAutoPause.Value;
}
if (requestScalingConfiguration_scalingConfiguration_SecondsUntilAutoPause != null)
{
request.ScalingConfiguration.SecondsUntilAutoPause = requestScalingConfiguration_scalingConfiguration_SecondsUntilAutoPause.Value;
requestScalingConfigurationIsNull = false;
}
System.String requestScalingConfiguration_scalingConfiguration_TimeoutAction = null;
if (cmdletContext.ScalingConfiguration_TimeoutAction != null)
{
requestScalingConfiguration_scalingConfiguration_TimeoutAction = cmdletContext.ScalingConfiguration_TimeoutAction;
}
if (requestScalingConfiguration_scalingConfiguration_TimeoutAction != null)
{
request.ScalingConfiguration.TimeoutAction = requestScalingConfiguration_scalingConfiguration_TimeoutAction;
requestScalingConfigurationIsNull = false;
}
// determine if request.ScalingConfiguration should be set to null
if (requestScalingConfigurationIsNull)
{
request.ScalingConfiguration = null;
}
// populate ServerlessV2ScalingConfiguration
var requestServerlessV2ScalingConfigurationIsNull = true;
request.ServerlessV2ScalingConfiguration = new Amazon.RDS.Model.ServerlessV2ScalingConfiguration();
System.Double? requestServerlessV2ScalingConfiguration_serverlessV2ScalingConfiguration_MaxCapacity = null;
if (cmdletContext.ServerlessV2ScalingConfiguration_MaxCapacity != null)
{
requestServerlessV2ScalingConfiguration_serverlessV2ScalingConfiguration_MaxCapacity = cmdletContext.ServerlessV2ScalingConfiguration_MaxCapacity.Value;
}
if (requestServerlessV2ScalingConfiguration_serverlessV2ScalingConfiguration_MaxCapacity != null)
{
request.ServerlessV2ScalingConfiguration.MaxCapacity = requestServerlessV2ScalingConfiguration_serverlessV2ScalingConfiguration_MaxCapacity.Value;
requestServerlessV2ScalingConfigurationIsNull = false;
}
System.Double? requestServerlessV2ScalingConfiguration_serverlessV2ScalingConfiguration_MinCapacity = null;
if (cmdletContext.ServerlessV2ScalingConfiguration_MinCapacity != null)
{
requestServerlessV2ScalingConfiguration_serverlessV2ScalingConfiguration_MinCapacity = cmdletContext.ServerlessV2ScalingConfiguration_MinCapacity.Value;
}
if (requestServerlessV2ScalingConfiguration_serverlessV2ScalingConfiguration_MinCapacity != null)
{
request.ServerlessV2ScalingConfiguration.MinCapacity = requestServerlessV2ScalingConfiguration_serverlessV2ScalingConfiguration_MinCapacity.Value;
requestServerlessV2ScalingConfigurationIsNull = false;
}
// determine if request.ServerlessV2ScalingConfiguration should be set to null
if (requestServerlessV2ScalingConfigurationIsNull)
{
request.ServerlessV2ScalingConfiguration = null;
}
if (cmdletContext.SnapshotIdentifier != null)
{
request.SnapshotIdentifier = cmdletContext.SnapshotIdentifier;
}
if (cmdletContext.StorageType != null)
{
request.StorageType = cmdletContext.StorageType;
}
if (cmdletContext.Tag != null)
{
request.Tags = cmdletContext.Tag;
}
if (cmdletContext.VpcSecurityGroupId != null)
{
request.VpcSecurityGroupIds = cmdletContext.VpcSecurityGroupId;
}
CmdletOutput output;
// issue call
var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint);
try
{
var response = CallAWSServiceOperation(client, request);
object pipelineOutput = null;
pipelineOutput = cmdletContext.Select(response, this);
output = new CmdletOutput
{
PipelineOutput = pipelineOutput,
ServiceResponse = response
};
}
catch (Exception e)
{
output = new CmdletOutput { ErrorResponse = e };
}
return output;
}
public ExecutorContext CreateContext()
{
return new CmdletContext();
}
#endregion
#region AWS Service Operation Call
private Amazon.RDS.Model.RestoreDBClusterFromSnapshotResponse CallAWSServiceOperation(IAmazonRDS client, Amazon.RDS.Model.RestoreDBClusterFromSnapshotRequest request)
{
Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon Relational Database Service", "RestoreDBClusterFromSnapshot");
try
{
#if DESKTOP
return client.RestoreDBClusterFromSnapshot(request);
#elif CORECLR
return client.RestoreDBClusterFromSnapshotAsync(request).GetAwaiter().GetResult();
#else
#error "Unknown build edition"
#endif
}
catch (AmazonServiceException exc)
{
var webException = exc.InnerException as System.Net.WebException;
if (webException != null)
{
throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException);
}
throw;
}
}
#endregion
internal partial class CmdletContext : ExecutorContext
{
public List<System.String> AvailabilityZone { get; set; }
public System.Int64? BacktrackWindow { get; set; }
public System.Boolean? CopyTagsToSnapshot { get; set; }
public System.String DatabaseName { get; set; }
public System.String DBClusterIdentifier { get; set; }
public System.String DBClusterInstanceClass { get; set; }
public System.String DBClusterParameterGroupName { get; set; }
public System.String DBSubnetGroupName { get; set; }
public System.Boolean? DeletionProtection { get; set; }
public System.String Domain { get; set; }
public System.String DomainIAMRoleName { get; set; }
public List<System.String> EnableCloudwatchLogsExport { get; set; }
public System.Boolean? EnableIAMDatabaseAuthentication { get; set; }
public System.String Engine { get; set; }
public System.String EngineMode { get; set; }
public System.String EngineVersion { get; set; }
public System.Int32? Iops { get; set; }
public System.String KmsKeyId { get; set; }
public System.String NetworkType { get; set; }
public System.String OptionGroupName { get; set; }
public System.Int32? Port { get; set; }
public System.Boolean? PubliclyAccessible { get; set; }
public System.Boolean? ScalingConfiguration_AutoPause { get; set; }
public System.Int32? ScalingConfiguration_MaxCapacity { get; set; }
public System.Int32? ScalingConfiguration_MinCapacity { get; set; }
public System.Int32? ScalingConfiguration_SecondsBeforeTimeout { get; set; }
public System.Int32? ScalingConfiguration_SecondsUntilAutoPause { get; set; }
public System.String ScalingConfiguration_TimeoutAction { get; set; }
public System.Double? ServerlessV2ScalingConfiguration_MaxCapacity { get; set; }
public System.Double? ServerlessV2ScalingConfiguration_MinCapacity { get; set; }
public System.String SnapshotIdentifier { get; set; }
public System.String StorageType { get; set; }
public List<Amazon.RDS.Model.Tag> Tag { get; set; }
public List<System.String> VpcSecurityGroupId { get; set; }
public System.Func<Amazon.RDS.Model.RestoreDBClusterFromSnapshotResponse, RestoreRDSDBClusterFromSnapshotCmdlet, object> Select { get; set; } =
(response, cmdlet) => response.DBCluster;
}
}
}