rds

type AddRoleToDBClusterInput struct {
	// The name of the DB cluster to associate the IAM role with.
	DBClusterIdentifier *string
	// The Amazon Resource Name (ARN) of the IAM role to associate with the Aurora DB
	// cluster, for example arn:aws:iam::123456789012:role/AuroraAccessRole.
	RoleArn *string
	// The name of the feature for the DB cluster that the IAM role is to be associated
	// with. For the list of supported feature names, see DBEngineVersion ().
	FeatureName *string
}

type AddRoleToDBClusterOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AddRoleToDBInstanceInput struct {
	// The name of the feature for the DB instance that the IAM role is to be
	// associated with. For the list of supported feature names, see DBEngineVersion
	// ().
	FeatureName *string
	// The name of the DB instance to associate the IAM role with.
	DBInstanceIdentifier *string
	// The Amazon Resource Name (ARN) of the IAM role to associate with the DB
	// instance, for example arn:aws:iam::123456789012:role/AccessRole.
	RoleArn *string
}

type AddRoleToDBInstanceOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AddSourceIdentifierToSubscriptionInput struct {
	// The identifier of the event source to be added. Constraints:
	//
	//     * If the
	// source type is a DB instance, then a DBInstanceIdentifier must be supplied.
	//
	//
	// * If the source type is a DB security group, a DBSecurityGroupName must be
	// supplied.
	//
	//     * If the source type is a DB parameter group, a
	// DBParameterGroupName must be supplied.
	//
	//     * If the source type is a DB
	// snapshot, a DBSnapshotIdentifier must be supplied.
	SourceIdentifier *string
	// The name of the RDS event notification subscription you want to add a source
	// identifier to.
	SubscriptionName *string
}

type AddSourceIdentifierToSubscriptionOutput struct {
	// Contains the results of a successful invocation of the
	// DescribeEventSubscriptions action.
	EventSubscription *types.EventSubscription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AddTagsToResourceInput struct {
	// The Amazon RDS resource that the tags are added to. This value is an Amazon
	// Resource Name (ARN). For information about creating an ARN, see  Constructing an
	// RDS Amazon Resource Name (ARN)
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Tagging.ARN.html#USER_Tagging.ARN.Constructing).
	ResourceName *string
	// The tags to be assigned to the Amazon RDS resource.
	Tags []*types.Tag
}

type AddTagsToResourceOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ApplyPendingMaintenanceActionInput struct {
	// The RDS Amazon Resource Name (ARN) of the resource that the pending maintenance
	// action applies to. For information about creating an ARN, see  Constructing an
	// RDS Amazon Resource Name (ARN)
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Tagging.ARN.html#USER_Tagging.ARN.Constructing).
	ResourceIdentifier *string
	// A value that specifies the type of opt-in request, or undoes an opt-in request.
	// An opt-in request of type immediate can't be undone. Valid values:
	//
	//     *
	// immediate - Apply the maintenance action immediately.
	//
	//     * next-maintenance -
	// Apply the maintenance action during the next maintenance window for the
	// resource.
	//
	//     * undo-opt-in - Cancel any existing next-maintenance opt-in
	// requests.
	OptInType *string
	// The pending maintenance action to apply to this resource. Valid values:
	// system-update, db-upgrade, hardware-maintenance, ca-certificate-rotation
	ApplyAction *string
}

type ApplyPendingMaintenanceActionOutput struct {
	// Describes the pending maintenance actions for a resource.
	ResourcePendingMaintenanceActions *types.ResourcePendingMaintenanceActions

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AuthorizeDBSecurityGroupIngressInput struct {
	// AWS account number of the owner of the EC2 security group specified in the
	// EC2SecurityGroupName parameter. The AWS access key ID isn't an acceptable value.
	// For VPC DB security groups, EC2SecurityGroupId must be provided. Otherwise,
	// EC2SecurityGroupOwnerId and either EC2SecurityGroupName or EC2SecurityGroupId
	// must be provided.
	EC2SecurityGroupOwnerId *string
	// The IP range to authorize.
	CIDRIP *string
	// Name of the EC2 security group to authorize. For VPC DB security groups,
	// EC2SecurityGroupId must be provided. Otherwise, EC2SecurityGroupOwnerId and
	// either EC2SecurityGroupName or EC2SecurityGroupId must be provided.
	EC2SecurityGroupName *string
	// The name of the DB security group to add authorization to.
	DBSecurityGroupName *string
	// Id of the EC2 security group to authorize. For VPC DB security groups,
	// EC2SecurityGroupId must be provided. Otherwise, EC2SecurityGroupOwnerId and
	// either EC2SecurityGroupName or EC2SecurityGroupId must be provided.
	EC2SecurityGroupId *string
}

type AuthorizeDBSecurityGroupIngressOutput struct {
	// Contains the details for an Amazon RDS DB security group. This data type is used
	// as a response element in the DescribeDBSecurityGroups action.
	DBSecurityGroup *types.DBSecurityGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type BacktrackDBClusterInput struct {
	// The timestamp of the time to backtrack the DB cluster to, specified in ISO 8601
	// format. For more information about ISO 8601, see the ISO8601 Wikipedia page.
	// (http://en.wikipedia.org/wiki/ISO_8601) If the specified time isn't a consistent
	// time for the DB cluster, Aurora automatically chooses the nearest possible
	// consistent time for the DB cluster. Constraints:
	//
	//     * Must contain a valid ISO
	// 8601 timestamp.
	//
	//     * Can't contain a timestamp set in the future.
	//
	// Example:
	// 2017-07-08T18:00Z
	BacktrackTo *time.Time
	// The DB cluster identifier of the DB cluster to be backtracked. This parameter is
	// stored as a lowercase string. Constraints:
	//
	//     * Must contain from 1 to 63
	// alphanumeric characters or hyphens.
	//
	//     * First character must be a letter.
	//
	//
	// * Can't end with a hyphen or contain two consecutive hyphens.
	//
	// Example:
	// my-cluster1
	DBClusterIdentifier *string
	// A value that indicates whether to backtrack the DB cluster to the earliest
	// possible backtrack time when BacktrackTo is set to a timestamp earlier than the
	// earliest backtrack time. When this parameter is disabled and BacktrackTo is set
	// to a timestamp earlier than the earliest backtrack time, an error occurs.
	UseEarliestTimeOnPointInTimeUnavailable *bool
	// A value that indicates whether to force the DB cluster to backtrack when binary
	// logging is enabled. Otherwise, an error occurs when binary logging is enabled.
	Force *bool
}

type BacktrackDBClusterOutput struct {
	// The timestamp of the time to which the DB cluster was backtracked.
	BacktrackTo *time.Time
	// The timestamp of the time at which the backtrack was requested.
	BacktrackRequestCreationTime *time.Time
	// Contains a user-supplied DB cluster identifier. This identifier is the unique
	// key that identifies a DB cluster.
	DBClusterIdentifier *string
	// The timestamp of the time from which the DB cluster was backtracked.
	BacktrackedFrom *time.Time
	// Contains the backtrack identifier.
	BacktrackIdentifier *string
	// The status of the backtrack. This property returns one of the following
	// values:
	//
	//     * applying - The backtrack is currently being applied to or rolled
	// back from the DB cluster.
	//
	//     * completed - The backtrack has successfully been
	// applied to or rolled back from the DB cluster.
	//
	//     * failed - An error occurred
	// while the backtrack was applied to or rolled back from the DB cluster.
	//
	//     *
	// pending - The backtrack is currently pending application to or rollback from the
	// DB cluster.
	Status *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CancelExportTaskInput struct {
	// The identifier of the snapshot export task to cancel.
	ExportTaskIdentifier *string
}

type CancelExportTaskOutput struct {
	// The name of the IAM role that is used to write to Amazon S3 when exporting a
	// snapshot.
	IamRoleArn *string
	// The total amount of data exported, in gigabytes.
	TotalExtractedDataInGB *int32
	// The Amazon Resource Name (ARN) of the snapshot exported to Amazon S3.
	SourceArn *string
	// The Amazon S3 bucket that the snapshot is exported to.
	S3Bucket *string
	// The time that the snapshot was created.
	SnapshotTime *time.Time
	// The progress status of the export task.
	Status *string
	// A unique identifier for the snapshot export task. This ID isn't an identifier
	// for the Amazon S3 bucket where the snapshot is exported to.
	ExportTaskIdentifier *string
	// The reason the export failed, if it failed.
	FailureCause *string
	// The progress of the snapshot export task as a percentage.
	PercentProgress *int32
	// The Amazon S3 bucket prefix that is the file name and path of the exported
	// snapshot.
	S3Prefix *string
	// The ID of the AWS KMS key that is used to encrypt the snapshot when it's
	// exported to Amazon S3. The KMS key ID is the Amazon Resource Name (ARN), the KMS
	// key identifier, or the KMS key alias for the KMS encryption key. The IAM role
	// used for the snapshot export must have encryption and decryption permissions to
	// use this KMS key.
	KmsKeyId *string
	// The time that the snapshot export task completed.
	TaskEndTime *time.Time
	// The data exported from the snapshot. Valid values are the following:
	//
	//     *
	// database - Export all the data from a specified database.
	//
	//     * database.table
	// table-name - Export a table of the snapshot. This format is valid only for RDS
	// for MySQL, RDS for MariaDB, and Aurora MySQL.
	//
	//     * database.schema schema-name
	// - Export a database schema of the snapshot. This format is valid only for RDS
	// for PostgreSQL and Aurora PostgreSQL.
	//
	//     * database.schema.table table-name -
	// Export a table of the database schema. This format is valid only for RDS for
	// PostgreSQL and Aurora PostgreSQL.
	ExportOnly []*string
	// A warning about the snapshot export task.
	WarningMessage *string
	// The time that the snapshot export task started.
	TaskStartTime *time.Time

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type Client struct {
	// contains filtered or unexported fields
}

type CopyDBClusterParameterGroupInput struct {
	// A description for the copied DB cluster parameter group.
	TargetDBClusterParameterGroupDescription *string
	// The identifier for the copied DB cluster parameter group. Constraints:
	//
	//     *
	// Can't be null, empty, or blank
	//
	//     * Must contain from 1 to 255 letters,
	// numbers, or hyphens
	//
	//     * First character must be a letter
	//
	//     * Can't end
	// with a hyphen or contain two consecutive hyphens
	//
	// Example:
	// my-cluster-param-group1
	TargetDBClusterParameterGroupIdentifier *string
	// The identifier or Amazon Resource Name (ARN) for the source DB cluster parameter
	// group. For information about creating an ARN, see  Constructing an ARN for
	// Amazon RDS
	// (https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_Tagging.ARN.html#USER_Tagging.ARN.Constructing)
	// in the Amazon Aurora User Guide. Constraints:
	//
	//     * Must specify a valid DB
	// cluster parameter group.
	//
	//     * If the source DB cluster parameter group is in
	// the same AWS Region as the copy, specify a valid DB parameter group identifier,
	// for example my-db-cluster-param-group, or a valid ARN.
	//
	//     * If the source DB
	// parameter group is in a different AWS Region than the copy, specify a valid DB
	// cluster parameter group ARN, for example
	// arn:aws:rds:us-east-1:123456789012:cluster-pg:custom-cluster-group1.
	SourceDBClusterParameterGroupIdentifier *string
	// A list of tags. For more information, see Tagging Amazon RDS Resources
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Tagging.html) in
	// the Amazon RDS User Guide.
	Tags []*types.Tag
}

type CopyDBClusterParameterGroupOutput struct {
	// Contains the details of an Amazon RDS DB cluster parameter group. This data type
	// is used as a response element in the DescribeDBClusterParameterGroups action.
	DBClusterParameterGroup *types.DBClusterParameterGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CopyDBClusterSnapshotInput struct {
	// The identifier of the new DB cluster snapshot to create from the source DB
	// cluster snapshot. This parameter isn't case-sensitive. Constraints:
	//
	//     * Must
	// contain from 1 to 63 letters, numbers, or hyphens.
	//
	//     * First character must
	// be a letter.
	//
	//     * Can't end with a hyphen or contain two consecutive
	// hyphens.
	//
	// Example: my-cluster-snapshot2
	TargetDBClusterSnapshotIdentifier *string
	// The URL that contains a Signature Version 4 signed request for the
	// CopyDBClusterSnapshot API action in the AWS Region that contains the source DB
	// cluster snapshot to copy. The PreSignedUrl parameter must be used when copying
	// an encrypted DB cluster snapshot from another AWS Region. Don't specify
	// PreSignedUrl when you are copying an encrypted DB cluster snapshot in the same
	// AWS Region. The pre-signed URL must be a valid request for the
	// CopyDBClusterSnapshot API action that can be executed in the source AWS Region
	// that contains the encrypted DB cluster snapshot to be copied. The pre-signed URL
	// request must contain the following parameter values:  <ul> <li> <p>
	// <code>KmsKeyId</code> - The AWS KMS key identifier for the key to use to encrypt
	// the copy of the DB cluster snapshot in the destination AWS Region. This is the
	// same identifier for both the <code>CopyDBClusterSnapshot</code> action that is
	// called in the destination AWS Region, and the action contained in the pre-signed
	// URL.</p> </li> <li> <p> <code>DestinationRegion</code> - The name of the AWS
	// Region that the DB cluster snapshot is to be created in.</p> </li> <li> <p>
	// <code>SourceDBClusterSnapshotIdentifier</code> - The DB cluster snapshot
	// identifier for the encrypted DB cluster snapshot to be copied. This identifier
	// must be in the Amazon Resource Name (ARN) format for the source AWS Region. For
	// example, if you are copying an encrypted DB cluster snapshot from the us-west-2
	// AWS Region, then your <code>SourceDBClusterSnapshotIdentifier</code> looks like
	// the following example:
	// <code>arn:aws:rds:us-west-2:123456789012:cluster-snapshot:aurora-cluster1-snapshot-20161115</code>.</p>
	// </li> </ul> <p>To learn how to generate a Signature Version 4 signed request,
	// see <a
	// href="https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html">
	// Authenticating Requests: Using Query Parameters (AWS Signature Version 4)</a>
	// and <a
	// href="https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html">
	// Signature Version 4 Signing Process</a>.</p> <note> <p>If you are using an AWS
	// SDK tool or the AWS CLI, you can specify <code>SourceRegion</code> (or
	// <code>--source-region</code> for the AWS CLI) instead of specifying
	// <code>PreSignedUrl</code> manually. Specifying <code>SourceRegion</code>
	// autogenerates a pre-signed URL that is a valid request for the operation that
	// can be executed in the source AWS Region.</p> </note>
	PreSignedUrl *string
	// The identifier of the DB cluster snapshot to copy. This parameter isn't
	// case-sensitive. You can't copy an encrypted, shared DB cluster snapshot from one
	// AWS Region to another. Constraints:
	//
	//     * Must specify a valid system snapshot
	// in the "available" state.
	//
	//     * If the source snapshot is in the same AWS
	// Region as the copy, specify a valid DB snapshot identifier.
	//
	//     * If the source
	// snapshot is in a different AWS Region than the copy, specify a valid DB cluster
	// snapshot ARN. For more information, go to  Copying Snapshots Across AWS Regions
	// (https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_CopySnapshot.html#USER_CopySnapshot.AcrossRegions)
	// in the Amazon Aurora User Guide.
	//
	// Example: my-cluster-snapshot1
	SourceDBClusterSnapshotIdentifier *string
	// A value that indicates whether to copy all tags from the source DB cluster
	// snapshot to the target DB cluster snapshot. By default, tags are not copied.
	CopyTags *bool
	// A list of tags. For more information, see Tagging Amazon RDS Resources
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Tagging.html) in
	// the Amazon RDS User Guide.
	Tags []*types.Tag
	// The AWS KMS key ID for an encrypted DB cluster snapshot. The KMS key ID is the
	// Amazon Resource Name (ARN), KMS key identifier, or the KMS key alias for the KMS
	// encryption key.  <p>If you copy an encrypted DB cluster snapshot from your AWS
	// account, you can specify a value for <code>KmsKeyId</code> to encrypt the copy
	// with a new KMS encryption key. If you don't specify a value for
	// <code>KmsKeyId</code>, then the copy of the DB cluster snapshot is encrypted
	// with the same KMS key as the source DB cluster snapshot. </p> <p>If you copy an
	// encrypted DB cluster snapshot that is shared from another AWS account, then you
	// must specify a value for <code>KmsKeyId</code>. </p> <p>To copy an encrypted DB
	// cluster snapshot to another AWS Region, you must set <code>KmsKeyId</code> to
	// the KMS key ID you want to use to encrypt the copy of the DB cluster snapshot in
	// the destination AWS Region. KMS encryption keys are specific to the AWS Region
	// that they are created in, and you can't use encryption keys from one AWS Region
	// in another AWS Region.</p> <p>If you copy an unencrypted DB cluster snapshot and
	// specify a value for the <code>KmsKeyId</code> parameter, an error is
	// returned.</p>
	KmsKeyId *string
}

type CopyDBClusterSnapshotOutput struct {
	// Contains the details for an Amazon RDS DB cluster snapshot This data type is
	// used as a response element in the DescribeDBClusterSnapshots action.
	DBClusterSnapshot *types.DBClusterSnapshot

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CopyDBParameterGroupInput struct {
	// The identifier or ARN for the source DB parameter group. For information about
	// creating an ARN, see  Constructing an ARN for Amazon RDS
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Tagging.ARN.html#USER_Tagging.ARN.Constructing)
	// in the Amazon RDS User Guide. Constraints:
	//
	//     * Must specify a valid DB
	// parameter group.
	//
	//     * Must specify a valid DB parameter group identifier, for
	// example my-db-param-group, or a valid ARN.
	SourceDBParameterGroupIdentifier *string
	// A list of tags. For more information, see Tagging Amazon RDS Resources
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Tagging.html) in
	// the Amazon RDS User Guide.
	Tags []*types.Tag
	// The identifier for the copied DB parameter group. Constraints:
	//
	//     * Can't be
	// null, empty, or blank
	//
	//     * Must contain from 1 to 255 letters, numbers, or
	// hyphens
	//
	//     * First character must be a letter
	//
	//     * Can't end with a hyphen
	// or contain two consecutive hyphens
	//
	// Example: my-db-parameter-group
	TargetDBParameterGroupIdentifier *string
	// A description for the copied DB parameter group.
	TargetDBParameterGroupDescription *string
}

type CopyDBParameterGroupOutput struct {
	// Contains the details of an Amazon RDS DB parameter group. This data type is used
	// as a response element in the DescribeDBParameterGroups action.
	DBParameterGroup *types.DBParameterGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CopyDBSnapshotInput struct {
	// The AWS KMS key ID for an encrypted DB snapshot. The KMS key ID is the Amazon
	// Resource Name (ARN), KMS key identifier, or the KMS key alias for the KMS
	// encryption key.  <p>If you copy an encrypted DB snapshot from your AWS account,
	// you can specify a value for this parameter to encrypt the copy with a new KMS
	// encryption key. If you don't specify a value for this parameter, then the copy
	// of the DB snapshot is encrypted with the same KMS key as the source DB snapshot.
	// </p> <p>If you copy an encrypted DB snapshot that is shared from another AWS
	// account, then you must specify a value for this parameter. </p> <p>If you
	// specify this parameter when you copy an unencrypted snapshot, the copy is
	// encrypted. </p> <p>If you copy an encrypted snapshot to a different AWS Region,
	// then you must specify a KMS key for the destination AWS Region. KMS encryption
	// keys are specific to the AWS Region that they are created in, and you can't use
	// encryption keys from one AWS Region in another AWS Region. </p>
	KmsKeyId *string
	// A value that indicates whether to copy all tags from the source DB snapshot to
	// the target DB snapshot. By default, tags are not copied.
	CopyTags *bool
	// The identifier for the source DB snapshot.  <p>If the source snapshot is in the
	// same AWS Region as the copy, specify a valid DB snapshot identifier. For
	// example, you might specify <code>rds:mysql-instance1-snapshot-20130805</code>.
	// </p> <p>If the source snapshot is in a different AWS Region than the copy,
	// specify a valid DB snapshot ARN. For example, you might specify
	// <code>arn:aws:rds:us-west-2:123456789012:snapshot:mysql-instance1-snapshot-20130805</code>.
	// </p> <p>If you are copying from a shared manual DB snapshot, this parameter must
	// be the Amazon Resource Name (ARN) of the shared DB snapshot. </p> <p>If you are
	// copying an encrypted snapshot this parameter must be in the ARN format for the
	// source AWS Region, and must match the <code>SourceDBSnapshotIdentifier</code> in
	// the <code>PreSignedUrl</code> parameter. </p> <p>Constraints:</p> <ul> <li>
	// <p>Must specify a valid system snapshot in the "available" state.</p> </li>
	// </ul> <p>Example: <code>rds:mydb-2012-04-02-00-01</code> </p> <p>Example:
	// <code>arn:aws:rds:us-west-2:123456789012:snapshot:mysql-instance1-snapshot-20130805</code>
	// </p>
	SourceDBSnapshotIdentifier *string
	// The identifier for the copy of the snapshot.  <p>Constraints:</p> <ul> <li>
	// <p>Can't be null, empty, or blank</p> </li> <li> <p>Must contain from 1 to 255
	// 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-db-snapshot</code> </p>
	TargetDBSnapshotIdentifier *string
	// The URL that contains a Signature Version 4 signed request for the
	// CopyDBSnapshot API action in the source AWS Region that contains the source DB
	// snapshot to copy.  <p>You must specify this parameter when you copy an encrypted
	// DB snapshot from another AWS Region by using the Amazon RDS API. Don't specify
	// <code>PreSignedUrl</code> when you are copying an encrypted DB snapshot in the
	// same AWS Region.</p> <p>The presigned URL must be a valid request for the
	// <code>CopyDBSnapshot</code> API action that can be executed in the source AWS
	// Region that contains the encrypted DB snapshot to be copied. The presigned URL
	// request must contain the following parameter values: </p> <ul> <li> <p>
	// <code>DestinationRegion</code> - The AWS Region that the encrypted DB snapshot
	// is copied to. This AWS Region is the same one where the
	// <code>CopyDBSnapshot</code> action is called that contains this presigned URL.
	// </p> <p>For example, if you copy an encrypted DB snapshot from the us-west-2 AWS
	// Region to the us-east-1 AWS Region, then you call the
	// <code>CopyDBSnapshot</code> action in the us-east-1 AWS Region and provide a
	// presigned URL that contains a call to the <code>CopyDBSnapshot</code> action in
	// the us-west-2 AWS Region. For this example, the <code>DestinationRegion</code>
	// in the presigned URL must be set to the us-east-1 AWS Region. </p> </li> <li>
	// <p> <code>KmsKeyId</code> - The AWS KMS key identifier for the key to use to
	// encrypt the copy of the DB snapshot in the destination AWS Region. This is the
	// same identifier for both the <code>CopyDBSnapshot</code> action that is called
	// in the destination AWS Region, and the action contained in the presigned URL.
	// </p> </li> <li> <p> <code>SourceDBSnapshotIdentifier</code> - The DB snapshot
	// identifier for the encrypted snapshot to be copied. This identifier must be in
	// the Amazon Resource Name (ARN) format for the source AWS Region. For example, if
	// you are copying an encrypted DB snapshot from the us-west-2 AWS Region, then
	// your <code>SourceDBSnapshotIdentifier</code> looks like the following example:
	// <code>arn:aws:rds:us-west-2:123456789012:snapshot:mysql-instance1-snapshot-20161115</code>.
	// </p> </li> </ul> <p>To learn how to generate a Signature Version 4 signed
	// request, see <a
	// href="https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html">Authenticating
	// Requests: Using Query Parameters (AWS Signature Version 4)</a> and <a
	// href="https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html">Signature
	// Version 4 Signing Process</a>. </p> <note> <p>If you are using an AWS SDK tool
	// or the AWS CLI, you can specify <code>SourceRegion</code> (or
	// <code>--source-region</code> for the AWS CLI) instead of specifying
	// <code>PreSignedUrl</code> manually. Specifying <code>SourceRegion</code>
	// autogenerates a pre-signed URL that is a valid request for the operation that
	// can be executed in the source AWS Region.</p> </note>
	PreSignedUrl *string
	// A list of tags. For more information, see Tagging Amazon RDS Resources
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Tagging.html) in
	// the Amazon RDS User Guide.
	Tags []*types.Tag
	// The name of an option group to associate with the copy of the snapshot.
	// <p>Specify this option if you are copying a snapshot from one AWS Region to
	// another, and your DB instance uses a nondefault option group. If your source DB
	// instance uses Transparent Data Encryption for Oracle or Microsoft SQL Server,
	// you must specify this option when copying across AWS Regions. For more
	// information, see <a
	// href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CopySnapshot.html#USER_CopySnapshot.Options">Option
	// Group Considerations</a> in the <i>Amazon RDS User Guide.</i> </p>
	OptionGroupName *string
}

type CopyDBSnapshotOutput struct {
	// Contains the details of an Amazon RDS DB snapshot. This data type is used as a
	// response element in the DescribeDBSnapshots action.
	DBSnapshot *types.DBSnapshot

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CopyOptionGroupInput struct {
	// The identifier for the copied option group. Constraints:
	//
	//     * Can't be null,
	// empty, or blank
	//
	//     * Must contain from 1 to 255 letters, numbers, or hyphens
	//
	//
	// * First character must be a letter
	//
	//     * Can't end with a hyphen or contain two
	// consecutive hyphens
	//
	// Example: my-option-group
	TargetOptionGroupIdentifier *string
	// The description for the copied option group.
	TargetOptionGroupDescription *string
	// A list of tags. For more information, see Tagging Amazon RDS Resources
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Tagging.html) in
	// the Amazon RDS User Guide.
	Tags []*types.Tag
	// The identifier or ARN for the source option group. For information about
	// creating an ARN, see  Constructing an ARN for Amazon RDS
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Tagging.ARN.html#USER_Tagging.ARN.Constructing)
	// in the Amazon RDS User Guide. Constraints:
	//
	//     * Must specify a valid option
	// group.
	//
	//     * If the source option group is in the same AWS Region as the copy,
	// specify a valid option group identifier, for example my-option-group, or a valid
	// ARN.
	//
	//     * If the source option group is in a different AWS Region than the
	// copy, specify a valid option group ARN, for example
	// arn:aws:rds:us-west-2:123456789012:og:special-options.
	SourceOptionGroupIdentifier *string
}

type CopyOptionGroupOutput struct {
	//
	OptionGroup *types.OptionGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateCustomAvailabilityZoneInput struct {
	// The ID of an existing virtual private network (VPN) between the Amazon RDS
	// website and the VMware vSphere cluster.
	ExistingVpnId *string
	// The IP address of network traffic from your on-premises data center. A custom AZ
	// receives the network traffic. Specify this parameter only if ExistingVpnId isn't
	// specified.
	VpnTunnelOriginatorIP *string
	// The name of the custom Availability Zone (AZ).
	CustomAvailabilityZoneName *string
	// The name of a new VPN tunnel between the Amazon RDS website and the VMware
	// vSphere cluster. Specify this parameter only if ExistingVpnId isn't specified.
	NewVpnTunnelName *string
}

type CreateCustomAvailabilityZoneOutput struct {
	// A custom Availability Zone (AZ) is an on-premises AZ that is integrated with a
	// VMware vSphere cluster. For more information about RDS on VMware, see the  RDS
	// on VMware User Guide.
	// (https://docs.aws.amazon.com/AmazonRDS/latest/RDSonVMwareUserGuide/rds-on-vmware.html)
	CustomAvailabilityZone *types.CustomAvailabilityZone

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateDBClusterEndpointInput struct {
	// The tags to be assigned to the Amazon RDS resource.
	Tags []*types.Tag
	// The identifier to use for the new endpoint. This parameter is stored as a
	// lowercase string.
	DBClusterEndpointIdentifier *string
	// List of DB instance identifiers that are part of the custom endpoint group.
	StaticMembers []*string
	// List of DB instance identifiers that aren't part of the custom endpoint group.
	// All other eligible instances are reachable through the custom endpoint. Only
	// relevant if the list of static members is empty.
	ExcludedMembers []*string
	// The DB cluster identifier of the DB cluster associated with the endpoint. This
	// parameter is stored as a lowercase string.
	DBClusterIdentifier *string
	// The type of the endpoint. One of: READER, WRITER, ANY.
	EndpointType *string
}

type CreateDBClusterEndpointOutput struct {
	// The identifier associated with the endpoint. This parameter is stored as a
	// lowercase string.
	DBClusterEndpointIdentifier *string
	// The DB cluster identifier of the DB cluster associated with the endpoint. This
	// parameter is stored as a lowercase string.
	DBClusterIdentifier *string
	// The type of the endpoint. One of: READER, WRITER, CUSTOM.
	EndpointType *string
	// The DNS address of the endpoint.
	Endpoint *string
	// A unique system-generated identifier for an endpoint. It remains the same for
	// the whole life of the endpoint.
	DBClusterEndpointResourceIdentifier *string
	// List of DB instance identifiers that aren't part of the custom endpoint group.
	// All other eligible instances are reachable through the custom endpoint. Only
	// relevant if the list of static members is empty.
	ExcludedMembers []*string
	// The current status of the endpoint. One of: creating, available, deleting,
	// modifying.
	Status *string
	// The Amazon Resource Name (ARN) for the endpoint.
	DBClusterEndpointArn *string
	// The type associated with a custom endpoint. One of: READER, WRITER, ANY.
	CustomEndpointType *string
	// List of DB instance identifiers that are part of the custom endpoint group.
	StaticMembers []*string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateDBClusterInput struct {
	// A list of EC2 VPC security groups to associate with this DB cluster.
	VpcSecurityGroupIds []*string
	// A DB subnet group to associate with this DB cluster. Constraints: Must match the
	// name of an existing DBSubnetGroup. Must not be default. Example: mySubnetgroup
	DBSubnetGroupName *string
	// A value that indicates whether to copy all tags from the DB cluster to snapshots
	// of the DB cluster. The default is not to copy them.
	CopyTagsToSnapshot *bool
	// The list of log types that need to be enabled for exporting to CloudWatch Logs.
	// The values in the list depend on the DB engine being used. For more information,
	// see Publishing Database Logs to Amazon CloudWatch Logs
	// (https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_LogAccess.html#USER_LogAccess.Procedural.UploadtoCloudWatch)
	// in the Amazon Aurora User Guide.
	EnableCloudwatchLogsExports []*string
	// The name of the DB cluster parameter group to associate with this DB cluster. If
	// you do not specify a value, then the default DB cluster parameter group for the
	// specified DB engine and version is used. Constraints:
	//
	//     * If supplied, must
	// match the name of an existing DB cluster parameter group.
	DBClusterParameterGroupName *string
	// The number of days for which automated backups are retained. Default: 1
	// Constraints:
	//
	//     * Must be a value from 1 to 35
	BackupRetentionPeriod *int32
	// The name of the database engine to be used for this DB cluster. Valid Values:
	// aurora (for MySQL 5.6-compatible Aurora), aurora-mysql (for MySQL 5.7-compatible
	// Aurora), and aurora-postgresql
	Engine *string
	// The name of the master user for the DB cluster. Constraints:
	//
	//     * Must be 1 to
	// 16 letters or numbers.
	//
	//     * First character must be a letter.
	//
	//     * Can't be
	// a reserved word for the chosen database engine.
	MasterUsername *string
	// The target backtrack window, in seconds. To disable backtracking, set this value
	// to 0. Currently, Backtrack is only supported for Aurora MySQL DB clusters.
	// Default: 0 Constraints:
	//
	//     * If specified, this value must be set to a number
	// from 0 to 259,200 (72 hours).
	BacktrackWindow *int64
	// The global cluster ID of an Aurora cluster that becomes the primary cluster in
	// the new global database cluster.
	GlobalClusterIdentifier *string
	// 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.
	DeletionProtection *bool
	// A list of Availability Zones (AZs) where instances in the DB cluster can be
	// created. For information on AWS Regions and Availability Zones, see Choosing the
	// Regions and Availability Zones
	// (https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Concepts.RegionsAndAvailabilityZones.html)
	// in the Amazon Aurora User Guide.
	AvailabilityZones []*string
	// The AWS KMS key identifier for an encrypted DB cluster. The KMS key identifier
	// is the Amazon Resource Name (ARN) for the KMS encryption key. If you are
	// creating a DB cluster with the same AWS account that owns the KMS encryption key
	// used to encrypt the new DB cluster, then you can use the KMS key alias instead
	// of the ARN for the KMS encryption key. If an encryption key isn't specified in
	// KmsKeyId:
	//
	//     * If ReplicationSourceIdentifier identifies an encrypted source,
	// then Amazon RDS will use the encryption key used to encrypt the source.
	// Otherwise, Amazon RDS will use your default encryption key.
	//
	//     * If the
	// StorageEncrypted parameter is enabled and ReplicationSourceIdentifier isn't
	// specified, then Amazon RDS will use your default encryption key.
	//
	// AWS KMS
	// creates the default encryption key for your AWS account. Your AWS account has a
	// different default encryption key for each AWS Region. If you create a read
	// replica of an encrypted DB cluster in another AWS Region, you must set KmsKeyId
	// to a KMS key ID that is valid in the destination AWS Region. This key is used to
	// encrypt the read replica in that AWS Region.
	KmsKeyId *string
	// The name for your database of up to 64 alphanumeric characters. If you do not
	// provide a name, Amazon RDS doesn't create a database in the DB cluster you are
	// creating.
	DatabaseName *string
	// A URL that contains a Signature Version 4 signed request for the CreateDBCluster
	// action to be called in the source AWS Region where the DB cluster is replicated
	// from. You only need to specify PreSignedUrl when you are performing cross-region
	// replication from an encrypted DB cluster.  <p>The pre-signed URL must be a valid
	// request for the <code>CreateDBCluster</code> API action that can be executed in
	// the source AWS Region that contains the encrypted DB cluster to be copied.</p>
	// <p>The pre-signed URL request must contain the following parameter values:</p>
	// <ul> <li> <p> <code>KmsKeyId</code> - The AWS KMS key identifier for the key to
	// use to encrypt the copy of the DB cluster in the destination AWS Region. This
	// should refer to the same KMS key for both the <code>CreateDBCluster</code>
	// action that is called in the destination AWS Region, and the action contained in
	// the pre-signed URL.</p> </li> <li> <p> <code>DestinationRegion</code> - The name
	// of the AWS Region that Aurora read replica will be created in.</p> </li> <li>
	// <p> <code>ReplicationSourceIdentifier</code> - The DB cluster identifier for the
	// encrypted DB cluster to be copied. This identifier must be in the Amazon
	// Resource Name (ARN) format for the source AWS Region. For example, if you are
	// copying an encrypted DB cluster from the us-west-2 AWS Region, then your
	// <code>ReplicationSourceIdentifier</code> would look like Example:
	// <code>arn:aws:rds:us-west-2:123456789012:cluster:aurora-cluster1</code>.</p>
	// </li> </ul> <p>To learn how to generate a Signature Version 4 signed request,
	// see <a
	// href="https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html">
	// Authenticating Requests: Using Query Parameters (AWS Signature Version 4)</a>
	// and <a
	// href="https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html">
	// Signature Version 4 Signing Process</a>.</p> <note> <p>If you are using an AWS
	// SDK tool or the AWS CLI, you can specify <code>SourceRegion</code> (or
	// <code>--source-region</code> for the AWS CLI) instead of specifying
	// <code>PreSignedUrl</code> manually. Specifying <code>SourceRegion</code>
	// autogenerates a pre-signed URL that is a valid request for the operation that
	// can be executed in the source AWS Region.</p> </note>
	PreSignedUrl *string
	// The daily time range during which automated backups are created if automated
	// backups are enabled using the BackupRetentionPeriod parameter. The default is a
	// 30-minute window selected at random from an 8-hour block of time for each AWS
	// Region. To see the time blocks available, see  Adjusting the Preferred DB
	// Cluster Maintenance Window
	// (https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_UpgradeDBInstance.Maintenance.html#AdjustingTheMaintenanceWindow.Aurora)
	// in the Amazon Aurora User Guide. Constraints:
	//
	//     * Must be in the format
	// hh24:mi-hh24:mi.
	//
	//     * Must be in Universal Coordinated Time (UTC).
	//
	//     * Must
	// not conflict with the preferred maintenance window.
	//
	//     * Must be at least 30
	// minutes.
	PreferredBackupWindow *string
	// The weekly time range during which system maintenance can occur, in Universal
	// Coordinated Time (UTC). Format: ddd:hh24:mi-ddd:hh24:mi The default is a
	// 30-minute window selected at random from an 8-hour block of time for each AWS
	// Region, occurring on a random day of the week. To see the time blocks available,
	// see  Adjusting the Preferred DB Cluster Maintenance Window
	// (https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_UpgradeDBInstance.Maintenance.html#AdjustingTheMaintenanceWindow.Aurora)
	// in the Amazon Aurora User Guide. Valid Days: Mon, Tue, Wed, Thu, Fri, Sat, Sun.
	// Constraints: Minimum 30-minute window.
	PreferredMaintenanceWindow *string
	// A value that indicates whether to enable write operations to be forwarded from
	// this cluster to the primary cluster in an Aurora global database. The resulting
	// changes are replicated back to this cluster. This parameter only applies to DB
	// clusters that are secondary clusters in an Aurora global database. By default,
	// Aurora disallows write operations for secondary clusters.
	EnableGlobalWriteForwarding *bool
	// The password for the master database user. This password can contain any
	// printable ASCII character except "/", """, or "@". Constraints: Must contain
	// from 8 to 41 characters.
	MasterUserPassword *string
	// Tags to assign to the DB cluster.
	Tags []*types.Tag
	// The Amazon Resource Name (ARN) of the source DB instance or DB cluster if this
	// DB cluster is created as a read replica.
	ReplicationSourceIdentifier *string
	// Specify the name of the IAM role to be used when making API calls to the
	// Directory Service.
	DomainIAMRoleName *string
	// A value that indicates whether to enable mapping of AWS Identity and Access
	// Management (IAM) accounts to database accounts. By default, mapping is disabled.
	// <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>
	EnableIAMDatabaseAuthentication *bool
	// The Active Directory directory ID to create the DB cluster in. For Amazon Aurora
	// DB clusters, Amazon RDS can use Kerberos Authentication to authenticate users
	// that connect to the DB cluster. For more information, see Kerberos
	// Authentication
	// (https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/kerberos-authentication.html)
	// in the Amazon Aurora User Guide.
	Domain *string
	// A value that indicates whether the DB cluster is encrypted.
	StorageEncrypted *bool
	// A value that indicates that the DB cluster should be associated with the
	// specified CharacterSet.
	CharacterSetName *string
	// The DB engine mode of the DB cluster, either provisioned, serverless,
	// parallelquery, global, or multimaster. global engine mode only applies for
	// global database clusters created with Aurora MySQL version 5.6.10a. For higher
	// Aurora MySQL versions, the clusters in a global database use provisioned engine
	// mode. Limitations and requirements apply to some DB engine modes. For more
	// information, see the following sections in the Amazon Aurora User Guide:
	//
	//     *
	// Limitations of Aurora Serverless
	// (https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-serverless.html#aurora-serverless.limitations)
	//
	//
	// * Limitations of Parallel Query
	// (https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-mysql-parallel-query.html#aurora-mysql-parallel-query-limitations)
	//
	//
	// * Requirements for Aurora Global Databases
	// (https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database.html#aurora-global-database.limitations)
	//
	//
	// * Limitations of Multi-Master Clusters
	// (https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-multi-master.html#aurora-multi-master-limitations)
	EngineMode *string
	// The port number on which the instances in the DB cluster accept connections.
	// Default: 3306 if engine is set as aurora or 5432 if set to aurora-postgresql.
	Port *int32
	// A value that indicates whether to enable the HTTP endpoint for an Aurora
	// Serverless DB cluster. By default, the HTTP endpoint is disabled. When enabled,
	// the HTTP endpoint provides a connectionless web service API for running SQL
	// queries on the Aurora Serverless DB cluster. You can also query your database
	// from inside the RDS console with the query editor. For more information, see
	// Using the Data API for Aurora Serverless
	// (https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/data-api.html) in
	// the Amazon Aurora User Guide.
	EnableHttpEndpoint *bool
	// For DB clusters in serverless DB engine mode, the scaling properties of the DB
	// cluster.
	ScalingConfiguration *types.ScalingConfiguration
	// The DB cluster identifier. This parameter is stored as a lowercase string.
	// Constraints:
	//
	//     * Must contain from 1 to 63 letters, numbers, or hyphens.
	//
	//
	// * First character must be a letter.
	//
	//     * Can't end with a hyphen or contain
	// two consecutive hyphens.
	//
	// Example: my-cluster1
	DBClusterIdentifier *string
	// A value that indicates that the DB cluster should be associated with the
	// specified option group. Permanent options can't be removed from an option group.
	// The option group can't be removed from a DB cluster once it is associated with a
	// DB cluster.
	OptionGroupName *string
	// The version number of the database engine to use. To list all of the available
	// engine versions for aurora (for MySQL 5.6-compatible Aurora), use the following
	// command: aws rds describe-db-engine-versions --engine aurora --query
	// "DBEngineVersions[].EngineVersion" To list all of the available engine versions
	// for aurora-mysql (for MySQL 5.7-compatible Aurora), use the following command:
	// aws rds describe-db-engine-versions --engine aurora-mysql --query
	// "DBEngineVersions[].EngineVersion" To list all of the available engine versions
	// for aurora-postgresql, use the following command: aws rds
	// describe-db-engine-versions --engine aurora-postgresql --query
	// "DBEngineVersions[].EngineVersion" Aurora MySQL Example: 5.6.10a,
	// 5.6.mysql_aurora.1.19.2, 5.7.12, 5.7.mysql_aurora.2.04.5 Aurora PostgreSQL
	// Example: 9.6.3, 10.7
	EngineVersion *string
}

type CreateDBClusterOutput struct {
	// Contains the details of an Amazon Aurora DB cluster. This data type is used as a
	// response element in the DescribeDBClusters, StopDBCluster, and StartDBCluster
	// actions.
	DBCluster *types.DBCluster

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateDBClusterParameterGroupInput struct {
	// Tags to assign to the DB cluster parameter group.
	Tags []*types.Tag
	// The description for the DB cluster parameter group.
	Description *string
	// The DB cluster parameter group family name. A DB cluster parameter group can be
	// associated with one and only one DB cluster parameter group family, and can be
	// applied only to a DB cluster running a database engine and engine version
	// compatible with that DB cluster parameter group family. Aurora MySQL Example:
	// aurora5.6, aurora-mysql5.7 Aurora PostgreSQL Example: aurora-postgresql9.6
	DBParameterGroupFamily *string
	// The name of the DB cluster parameter group. Constraints:
	//
	//     * Must match the
	// name of an existing DB cluster parameter group.
	//
	// This value is stored as a
	// lowercase string.
	DBClusterParameterGroupName *string
}

type CreateDBClusterParameterGroupOutput struct {
	// Contains the details of an Amazon RDS DB cluster parameter group. This data type
	// is used as a response element in the DescribeDBClusterParameterGroups action.
	DBClusterParameterGroup *types.DBClusterParameterGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateDBClusterSnapshotInput struct {
	// The identifier of the DB cluster snapshot. This parameter is stored as a
	// lowercase string. Constraints:
	//
	//     * Must contain from 1 to 63 letters,
	// numbers, or hyphens.
	//
	//     * First character must be a letter.
	//
	//     * Can't end
	// with a hyphen or contain two consecutive hyphens.
	//
	// Example:
	// my-cluster1-snapshot1
	DBClusterSnapshotIdentifier *string
	// The identifier of the DB cluster to create a snapshot for. This parameter isn't
	// case-sensitive. Constraints:
	//
	//     * Must match the identifier of an existing
	// DBCluster.
	//
	// Example: my-cluster1
	DBClusterIdentifier *string
	// The tags to be assigned to the DB cluster snapshot.
	Tags []*types.Tag
}

type CreateDBClusterSnapshotOutput struct {
	// Contains the details for an Amazon RDS DB cluster snapshot This data type is
	// used as a response element in the DescribeDBClusterSnapshots action.
	DBClusterSnapshot *types.DBClusterSnapshot

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateDBInstanceInput struct {
	// A DB subnet group to associate with this DB instance. If there is no DB subnet
	// group, then it is a non-VPC DB instance.
	DBSubnetGroupName *string
	// A list of DB security groups to associate with this DB instance. Default: The
	// default DB security group for the database engine.
	DBSecurityGroups []*string
	// A value that indicates whether minor engine upgrades are applied automatically
	// to the DB instance during the maintenance window. By default, minor engine
	// upgrades are applied automatically.
	AutoMinorVersionUpgrade *bool
	// The compute and memory capacity of the DB instance, for example, db.m4.large.
	// Not all DB instance classes are available in all AWS Regions, or for all
	// database engines. For the full list of DB instance classes, and availability for
	// your engine, see DB Instance Class
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.DBInstanceClass.html)
	// in the Amazon RDS User Guide.
	DBInstanceClass *string
	// A list of Amazon EC2 VPC security groups to associate with this DB instance.
	// <p> <b>Amazon Aurora</b> </p> <p>Not applicable. The associated list of EC2 VPC
	// security groups is managed by the DB cluster.</p> <p>Default: The default EC2
	// VPC security group for the DB subnet group's VPC.</p>
	VpcSecurityGroupIds []*string
	// The list of log types that need to be enabled for exporting to CloudWatch Logs.
	// The values in the list depend on the DB engine being used. For more information,
	// see Publishing Database Logs to Amazon CloudWatch Logs
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_LogAccess.html#USER_LogAccess.Procedural.UploadtoCloudWatch)
	// in the Amazon Relational Database Service User Guide.
	EnableCloudwatchLogsExports []*string
	// The name of the database engine to be used for this instance.  <p>Not every
	// database engine is available for every AWS Region. </p> <p>Valid Values: </p>
	// <ul> <li> <p> <code>aurora</code> (for MySQL 5.6-compatible Aurora)</p> </li>
	// <li> <p> <code>aurora-mysql</code> (for MySQL 5.7-compatible Aurora)</p> </li>
	// <li> <p> <code>aurora-postgresql</code> </p> </li> <li> <p> <code>mariadb</code>
	// </p> </li> <li> <p> <code>mysql</code> </p> </li> <li> <p>
	// <code>oracle-ee</code> </p> </li> <li> <p> <code>oracle-se2</code> </p> </li>
	// <li> <p> <code>oracle-se1</code> </p> </li> <li> <p> <code>oracle-se</code> </p>
	// </li> <li> <p> <code>postgres</code> </p> </li> <li> <p>
	// <code>sqlserver-ee</code> </p> </li> <li> <p> <code>sqlserver-se</code> </p>
	// </li> <li> <p> <code>sqlserver-ex</code> </p> </li> <li> <p>
	// <code>sqlserver-web</code> </p> </li> </ul>
	Engine *string
	// A value that indicates whether the DB instance has deletion protection enabled.
	// The database can't be deleted when deletion protection is enabled. By default,
	// deletion protection is disabled. For more information, see  Deleting a DB
	// Instance
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_DeleteInstance.html).
	// Amazon Aurora Not applicable. You can enable or disable deletion protection for
	// the DB cluster. For more information, see CreateDBCluster. DB instances in a DB
	// cluster can be deleted even when deletion protection is enabled for the DB
	// cluster.
	DeletionProtection *bool
	// The meaning of this parameter differs according to the database engine you use.
	// MySQL The name of the database to create when the DB instance is created. If
	// this parameter isn't specified, no database is created in the DB instance.
	// Constraints:
	//
	//     * Must contain 1 to 64 letters or numbers.
	//
	//     * Can't be a
	// word reserved by the specified database engine
	//
	// MariaDB The name of the database
	// to create when the DB instance is created. If this parameter isn't specified, no
	// database is created in the DB instance. Constraints:
	//
	//     * Must contain 1 to 64
	// letters or numbers.
	//
	//     * Can't be a word reserved by the specified database
	// engine
	//
	// PostgreSQL The name of the database to create when the DB instance is
	// created. If this parameter isn't specified, the default "postgres" database is
	// created in the DB instance. Constraints:
	//
	//     * Must contain 1 to 63 letters,
	// numbers, or underscores.
	//
	//     * Must begin with a letter or an underscore.
	// Subsequent characters can be letters, underscores, or digits (0-9).
	//
	//     * Can't
	// be a word reserved by the specified database engine
	//
	// Oracle The Oracle System ID
	// (SID) of the created DB instance. If you specify null, the default value ORCL is
	// used. You can't specify the string NULL, or any other reserved word, for DBName.
	// Default: ORCL Constraints:
	//
	//     * Can't be longer than 8 characters
	//
	// SQL Server
	// Not applicable. Must be null. Amazon Aurora The name of the database to create
	// when the primary instance of the DB cluster is created. If this parameter isn't
	// specified, no database is created in the DB instance. Constraints:
	//
	//     * Must
	// contain 1 to 64 letters or numbers.
	//
	//     * Can't be a word reserved by the
	// specified database engine
	DBName *string
	// The upper limit to which Amazon RDS can automatically scale the storage of the
	// DB instance.
	MaxAllocatedStorage *int32
	// A value that indicates whether to copy tags from the DB instance to snapshots of
	// the DB instance. By default, tags are not copied. Amazon Aurora Not applicable.
	// Copying tags to snapshots is managed by the DB cluster. Setting this value for
	// an Aurora DB instance has no effect on the DB cluster setting.
	CopyTagsToSnapshot *bool
	// The name for the master user.  <p> <b>Amazon Aurora</b> </p> <p>Not applicable.
	// The name for the master user is managed by the DB cluster. </p> <p>
	// <b>MariaDB</b> </p> <p>Constraints:</p> <ul> <li> <p>Required for MariaDB.</p>
	// </li> <li> <p>Must be 1 to 16 letters or numbers.</p> </li> <li> <p>Can't be a
	// reserved word for the chosen database engine.</p> </li> </ul> <p> <b>Microsoft
	// SQL Server</b> </p> <p>Constraints:</p> <ul> <li> <p>Required for SQL
	// Server.</p> </li> <li> <p>Must be 1 to 128 letters or numbers.</p> </li> <li>
	// <p>The first character must be a letter.</p> </li> <li> <p>Can't be a reserved
	// word for the chosen database engine.</p> </li> </ul> <p> <b>MySQL</b> </p>
	// <p>Constraints:</p> <ul> <li> <p>Required for MySQL.</p> </li> <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> <p> <b>Oracle</b> </p> <p>Constraints:</p> <ul> <li>
	// <p>Required for Oracle.</p> </li> <li> <p>Must be 1 to 30 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> <p>
	// <b>PostgreSQL</b> </p> <p>Constraints:</p> <ul> <li> <p>Required for
	// PostgreSQL.</p> </li> <li> <p>Must be 1 to 63 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>
	MasterUsername *string
	// The Availability Zone (AZ) where the database will be created. For information
	// on AWS Regions and Availability Zones, see Regions and Availability Zones
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RegionsAndAvailabilityZones.html).
	// Default: A random, system-chosen Availability Zone in the endpoint's AWS Region.
	// Example: us-east-1d Constraint: The AvailabilityZone parameter can't be
	// specified if the DB instance is a Multi-AZ deployment. The specified
	// Availability Zone must be in the same AWS Region as the current endpoint. If
	// you're creating a DB instance in an RDS on VMware environment, specify the
	// identifier of the custom Availability Zone to create the DB instance in. For
	// more information about RDS on VMware, see the  RDS on VMware User Guide.
	// (https://docs.aws.amazon.com/AmazonRDS/latest/RDSonVMwareUserGuide/rds-on-vmware.html)
	AvailabilityZone *string
	// The AWS KMS key identifier for an encrypted DB instance. The KMS key identifier
	// is the Amazon Resource Name (ARN) for the KMS encryption key. If you are
	// creating a DB instance with the same AWS account that owns the KMS encryption
	// key used to encrypt the new DB instance, then you can use the KMS key alias
	// instead of the ARN for the KM encryption key. Amazon Aurora Not applicable. The
	// KMS key identifier is managed by the DB cluster. For more information, see
	// CreateDBCluster.  <p>If <code>StorageEncrypted</code> is enabled, and you do not
	// specify a value for the <code>KmsKeyId</code> parameter, then Amazon RDS will
	// use your default encryption key. AWS KMS creates the default encryption key for
	// your AWS account. Your AWS account has a different default encryption key for
	// each AWS Region.</p>
	KmsKeyId *string
	// The daily time range during which automated backups are created if automated
	// backups are enabled, using the BackupRetentionPeriod parameter. For more
	// information, see The Backup Window
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithAutomatedBackups.html#USER_WorkingWithAutomatedBackups.BackupWindow)
	// in the Amazon RDS User Guide.  <p> <b>Amazon Aurora</b> </p> <p>Not applicable.
	// The daily time range for creating automated backups is managed by the DB
	// cluster.</p> <p> The default is a 30-minute window selected at random from an
	// 8-hour block of time for each AWS Region. To see the time blocks available, see
	// <a
	// href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_UpgradeDBInstance.Maintenance.html#AdjustingTheMaintenanceWindow">
	// Adjusting the Preferred DB Instance Maintenance Window</a> in the <i>Amazon RDS
	// 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>
	PreferredBackupWindow *string
	// The time zone of the DB instance. The time zone parameter is currently supported
	// only by Microsoft SQL Server
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_SQLServer.html#SQLServer.Concepts.General.TimeZone).
	Timezone *string
	// A value that indicates whether to enable Performance Insights for the DB
	// instance. For more information, see Using Amazon Performance Insights
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_PerfInsights.html)
	// in the Amazon Relational Database Service User Guide.
	EnablePerformanceInsights *bool
	// The time range each week during which system maintenance can occur, in Universal
	// Coordinated Time (UTC). For more information, see Amazon RDS Maintenance Window
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_UpgradeDBInstance.Maintenance.html#Concepts.DBMaintenance).
	// Format: ddd:hh24:mi-ddd:hh24:mi The default is a 30-minute window selected at
	// random from an 8-hour block of time for each AWS Region, occurring on a random
	// day of the week. Valid Days: Mon, Tue, Wed, Thu, Fri, Sat, Sun. Constraints:
	// Minimum 30-minute window.
	PreferredMaintenanceWindow *string
	// License model information for this DB instance. Valid values: license-included |
	// bring-your-own-license | general-public-license
	LicenseModel *string
	// The amount of Provisioned IOPS (input/output operations per second) to be
	// initially allocated for the DB instance. For information about valid Iops
	// values, see Amazon RDS Provisioned IOPS Storage to Improve Performance
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Storage.html#USER_PIOPS)
	// in the Amazon RDS User Guide. Constraints: For MariaDB, MySQL, Oracle, and
	// PostgreSQL DB instances, must be a multiple between .5 and 50 of the storage
	// amount for the DB instance. For SQL Server DB instances, must be a multiple
	// between 1 and 50 of the storage amount for the DB instance.
	Iops *int32
	// The interval, in seconds, between points when Enhanced Monitoring metrics are
	// collected for the DB instance. To disable collecting Enhanced Monitoring
	// metrics, specify 0. The default is 0. If MonitoringRoleArn is specified, then
	// you must also set MonitoringInterval to a value other than 0. Valid Values: 0,
	// 1, 5, 10, 15, 30, 60
	MonitoringInterval *int32
	// The password for the given ARN from the key store in order to access the device.
	TdeCredentialPassword *string
	// The name of the DB parameter group to associate with this DB instance. If you do
	// not specify a value, then the default DB parameter group for the specified DB
	// engine and version is used. Constraints:
	//
	//     * Must be 1 to 255 letters,
	// numbers, or hyphens.
	//
	//     * First character must be a letter
	//
	//     * Can't end
	// with a hyphen or contain two consecutive hyphens
	DBParameterGroupName *string
	// The Active Directory directory ID to create the DB instance in. Currently, only
	// Microsoft SQL Server and Oracle DB instances can be created in an Active
	// Directory Domain. For Microsoft SQL Server DB instances, Amazon RDS can use
	// Windows Authentication to authenticate users that connect to the DB instance.
	// For more information, see  Using Windows Authentication with an Amazon RDS DB
	// Instance Running Microsoft SQL Server
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_SQLServerWinAuth.html)
	// in the Amazon RDS User Guide. For Oracle DB instances, Amazon RDS can use
	// Kerberos Authentication to authenticate users that connect to the DB instance.
	// For more information, see  Using Kerberos Authentication with Amazon RDS for
	// Oracle
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/oracle-kerberos.html) in
	// the Amazon RDS User Guide.
	Domain *string
	// A value that indicates whether to enable mapping of AWS Identity and Access
	// Management (IAM) accounts to database accounts. By default, mapping is disabled.
	// You can enable IAM database authentication for the following database engines:
	// <p> <b>Amazon Aurora</b> </p> <p>Not applicable. Mapping AWS IAM accounts to
	// database accounts is managed by the DB cluster.</p> <p> <b>MySQL</b> </p> <ul>
	// <li> <p>For MySQL 5.6, minor version 5.6.34 or higher</p> </li> <li> <p>For
	// MySQL 5.7, minor version 5.7.16 or higher</p> </li> <li> <p>For MySQL 8.0, minor
	// version 8.0.16 or higher</p> </li> </ul> <p> <b>PostgreSQL</b> </p> <ul> <li>
	// <p>For PostgreSQL 9.5, minor version 9.5.15 or higher</p> </li> <li> <p>For
	// PostgreSQL 9.6, minor version 9.6.11 or higher</p> </li> <li> <p>PostgreSQL
	// 10.6, 10.7, and 10.9</p> </li> </ul> <p>For more information, see <a
	// href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/UsingWithRDS.IAMDBAuth.html">
	// IAM Database Authentication for MySQL and PostgreSQL</a> in the <i>Amazon RDS
	// User Guide.</i> </p>
	EnableIAMDatabaseAuthentication *bool
	// A value that specifies the order in which an Aurora Replica is promoted to the
	// primary instance after a failure of the existing primary instance. For more
	// information, see  Fault Tolerance for an Aurora DB Cluster
	// (https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.Managing.Backups.html#Aurora.Managing.FaultTolerance)
	// in the Amazon Aurora User Guide. Default: 1 Valid Values: 0 - 15
	PromotionTier *int32
	// The number of CPU cores and the number of threads per core for the DB instance
	// class of the DB instance.
	ProcessorFeatures []*types.ProcessorFeature
	// A value that indicates whether the DB instance is a Multi-AZ deployment. You
	// can't set the AvailabilityZone parameter if the DB instance is a Multi-AZ
	// deployment.
	MultiAZ *bool
	// The ARN for the IAM role that permits RDS to send enhanced monitoring metrics to
	// Amazon CloudWatch Logs. For example, arn:aws:iam:123456789012:role/emaccess. For
	// information on creating a monitoring role, go to Setting Up and Enabling
	// Enhanced Monitoring
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Monitoring.OS.html#USER_Monitoring.OS.Enabling)
	// in the Amazon RDS User Guide. If MonitoringInterval is set to a value other than
	// 0, then you must supply a MonitoringRoleArn value.
	MonitoringRoleArn *string
	// Tags to assign to the DB instance.
	Tags []*types.Tag
	// A value that indicates whether the DB instance is publicly accessible. When the
	// DB instance is publicly accessible, its DNS endpoint resolves to the private IP
	// address from within the DB instance's VPC, and to the public IP address from
	// outside of the DB instance's VPC. Access to the DB instance is ultimately
	// controlled by the security group it uses, and that public access is not
	// permitted if the security group assigned to the DB instance doesn't permit it.
	// When the DB instance isn't publicly accessible, it is an internal DB instance
	// with a DNS name that resolves to a private IP address. Default: The default
	// behavior varies depending on whether DBSubnetGroupName is specified. If
	// DBSubnetGroupName isn't specified, and PubliclyAccessible isn't specified, the
	// following applies:
	//
	//     * If the default VPC in the target region doesn’t have
	// an Internet gateway attached to it, the DB instance is private.
	//
	//     * If the
	// default VPC in the target region has an Internet gateway attached to it, the DB
	// instance is public.
	//
	// If DBSubnetGroupName is specified, and PubliclyAccessible
	// isn't specified, the following applies:
	//
	//     * If the subnets are part of a VPC
	// that doesn’t have an Internet gateway attached to it, the DB instance is
	// private.
	//
	//     * If the subnets are part of a VPC that has an Internet gateway
	// attached to it, the DB instance is public.
	PubliclyAccessible *bool
	// The password for the master user. The password can include any printable ASCII
	// character except "/", """, or "@".  <p> <b>Amazon Aurora</b> </p> <p>Not
	// applicable. The password for the master user is managed by the DB cluster.</p>
	// <p> <b>MariaDB</b> </p> <p>Constraints: Must contain from 8 to 41
	// characters.</p> <p> <b>Microsoft SQL Server</b> </p> <p>Constraints: Must
	// contain from 8 to 128 characters.</p> <p> <b>MySQL</b> </p> <p>Constraints: Must
	// contain from 8 to 41 characters.</p> <p> <b>Oracle</b> </p> <p>Constraints: Must
	// contain from 8 to 30 characters.</p> <p> <b>PostgreSQL</b> </p> <p>Constraints:
	// Must contain from 8 to 128 characters.</p>
	MasterUserPassword *string
	// The AWS KMS key identifier for encryption of Performance Insights data. The KMS
	// key ID is the Amazon Resource Name (ARN), KMS key identifier, or the KMS key
	// alias for the KMS encryption key. If you do not specify a value for
	// PerformanceInsightsKMSKeyId, then Amazon RDS uses your default encryption key.
	// AWS KMS creates the default encryption key for your AWS account. Your AWS
	// account has a different default encryption key for each AWS Region.
	PerformanceInsightsKMSKeyId *string
	// Specify the name of the IAM role to be used when making API calls to the
	// Directory Service.
	DomainIAMRoleName *string
	// The ARN from the key store with which to associate the instance for TDE
	// encryption.
	TdeCredentialArn *string
	// The port number on which the database accepts connections. MySQL Default: 3306
	// Valid values: 1150-65535 Type: Integer MariaDB Default: 3306 Valid values:
	// 1150-65535 Type: Integer PostgreSQL Default: 5432 Valid values: 1150-65535 Type:
	// Integer Oracle Default: 1521 Valid values: 1150-65535 SQL Server Default: 1433
	// Valid values: 1150-65535 except 1234, 1434, 3260, 3343, 3389, 47001, and
	// 49152-49156. Amazon Aurora Default: 3306 Valid values: 1150-65535 Type: Integer
	Port *int32
	// Indicates that the DB instance should be associated with the specified option
	// group. Permanent options, such as the TDE option for Oracle Advanced Security
	// TDE, can't be removed from an option group. Also, that option group can't be
	// removed from a DB instance once it is associated with a DB instance
	OptionGroupName *string
	// The identifier of the DB cluster that the instance will belong to.
	DBClusterIdentifier *string
	// For supported engines, indicates that the DB instance should be associated with
	// the specified CharacterSet.  <p> <b>Amazon Aurora</b> </p> <p>Not applicable.
	// The character set is managed by the DB cluster. For more information, see
	// <code>CreateDBCluster</code>.</p>
	CharacterSetName *string
	// The number of days for which automated backups are retained. Setting this
	// parameter to a positive number enables backups. Setting this parameter to 0
	// disables automated backups. Amazon Aurora Not applicable. The retention period
	// for automated backups is managed by the DB cluster. Default: 1 Constraints:
	//
	//
	// * Must be a value from 0 to 35
	//
	//     * Can't be set to 0 if the DB instance is a
	// source to read replicas
	BackupRetentionPeriod *int32
	// A value that indicates whether the DB instance is encrypted. By default, it
	// isn't encrypted.  <p> <b>Amazon Aurora</b> </p> <p>Not applicable. The
	// encryption for DB instances is managed by the DB cluster.</p>
	StorageEncrypted *bool
	// The amount of time, in days, to retain Performance Insights data. Valid values
	// are 7 or 731 (2 years).
	PerformanceInsightsRetentionPeriod *int32
	// The version number of the database engine to use. For a list of valid engine
	// versions, use the DescribeDBEngineVersions action. The following are the
	// database engines and links to information about the major and minor versions
	// that are available with Amazon RDS. Not every database engine is available for
	// every AWS Region.  <p> <b>Amazon Aurora</b> </p> <p>Not applicable. The version
	// number of the database engine to be used by the DB instance is managed by the DB
	// cluster.</p> <p> <b>MariaDB</b> </p> <p>See <a
	// href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_MariaDB.html#MariaDB.Concepts.VersionMgmt">MariaDB
	// on Amazon RDS Versions</a> in the <i>Amazon RDS User Guide.</i> </p> <p>
	// <b>Microsoft SQL Server</b> </p> <p>See <a
	// href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_SQLServer.html#SQLServer.Concepts.General.FeatureSupport">Version
	// and Feature Support on Amazon RDS</a> in the <i>Amazon RDS User Guide.</i> </p>
	// <p> <b>MySQL</b> </p> <p>See <a
	// href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_MySQL.html#MySQL.Concepts.VersionMgmt">MySQL
	// on Amazon RDS Versions</a> in the <i>Amazon RDS User Guide.</i> </p> <p>
	// <b>Oracle</b> </p> <p>See <a
	// href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.Oracle.PatchComposition.html">Oracle
	// Database Engine Release Notes</a> in the <i>Amazon RDS User Guide.</i> </p> <p>
	// <b>PostgreSQL</b> </p> <p>See <a
	// href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_PostgreSQL.html#PostgreSQL.Concepts.General.DBVersions">Supported
	// PostgreSQL Database Versions</a> in the <i>Amazon RDS User Guide.</i> </p>
	EngineVersion *string
	// Specifies the storage type to be associated with the DB instance. Valid values:
	// standard | gp2 | io1 If you specify io1, you must also include a value for the
	// Iops parameter. Default: io1 if the Iops parameter is specified, otherwise gp2
	StorageType *string
	// The amount of storage (in gibibytes) to allocate for the DB instance. Type:
	// Integer Amazon Aurora Not applicable. Aurora cluster volumes automatically grow
	// as the amount of data in your database increases, though you are only charged
	// for the space that you use in an Aurora cluster volume.  <p> <b>MySQL</b> </p>
	// <p>Constraints to the amount of storage for each storage type are the following:
	// </p> <ul> <li> <p>General Purpose (SSD) storage (gp2): Must be an integer from
	// 20 to 65536.</p> </li> <li> <p>Provisioned IOPS storage (io1): Must be an
	// integer from 100 to 65536.</p> </li> <li> <p>Magnetic storage (standard): Must
	// be an integer from 5 to 3072.</p> </li> </ul> <p> <b>MariaDB</b> </p>
	// <p>Constraints to the amount of storage for each storage type are the following:
	// </p> <ul> <li> <p>General Purpose (SSD) storage (gp2): Must be an integer from
	// 20 to 65536.</p> </li> <li> <p>Provisioned IOPS storage (io1): Must be an
	// integer from 100 to 65536.</p> </li> <li> <p>Magnetic storage (standard): Must
	// be an integer from 5 to 3072.</p> </li> </ul> <p> <b>PostgreSQL</b> </p>
	// <p>Constraints to the amount of storage for each storage type are the following:
	// </p> <ul> <li> <p>General Purpose (SSD) storage (gp2): Must be an integer from
	// 20 to 65536.</p> </li> <li> <p>Provisioned IOPS storage (io1): Must be an
	// integer from 100 to 65536.</p> </li> <li> <p>Magnetic storage (standard): Must
	// be an integer from 5 to 3072.</p> </li> </ul> <p> <b>Oracle</b> </p>
	// <p>Constraints to the amount of storage for each storage type are the following:
	// </p> <ul> <li> <p>General Purpose (SSD) storage (gp2): Must be an integer from
	// 20 to 65536.</p> </li> <li> <p>Provisioned IOPS storage (io1): Must be an
	// integer from 100 to 65536.</p> </li> <li> <p>Magnetic storage (standard): Must
	// be an integer from 10 to 3072.</p> </li> </ul> <p> <b>SQL Server</b> </p>
	// <p>Constraints to the amount of storage for each storage type are the following:
	// </p> <ul> <li> <p>General Purpose (SSD) storage (gp2):</p> <ul> <li>
	// <p>Enterprise and Standard editions: Must be an integer from 200 to 16384.</p>
	// </li> <li> <p>Web and Express editions: Must be an integer from 20 to 16384.</p>
	// </li> </ul> </li> <li> <p>Provisioned IOPS storage (io1):</p> <ul> <li>
	// <p>Enterprise and Standard editions: Must be an integer from 200 to 16384.</p>
	// </li> <li> <p>Web and Express editions: Must be an integer from 100 to
	// 16384.</p> </li> </ul> </li> <li> <p>Magnetic storage (standard):</p> <ul> <li>
	// <p>Enterprise and Standard editions: Must be an integer from 200 to 1024.</p>
	// </li> <li> <p>Web and Express editions: Must be an integer from 20 to 1024.</p>
	// </li> </ul> </li> </ul>
	AllocatedStorage *int32
	// The DB instance identifier. This parameter is stored as a lowercase string.
	// Constraints:
	//
	//     * Must contain from 1 to 63 letters, numbers, or hyphens.
	//
	//
	// * First character must be a letter.
	//
	//     * Can't end with a hyphen or contain
	// two consecutive hyphens.
	//
	// Example: mydbinstance
	DBInstanceIdentifier *string
}

type CreateDBInstanceOutput struct {
	// Contains the details of an Amazon RDS DB instance. This data type is used as a
	// response element in the DescribeDBInstances action.
	DBInstance *types.DBInstance

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateDBInstanceReadReplicaInput struct {
	// A value that indicates whether to copy all tags from the read replica to
	// snapshots of the read replica. By default, tags are not copied.
	CopyTagsToSnapshot *bool
	// The URL that contains a Signature Version 4 signed request for the
	// CreateDBInstanceReadReplica API action in the source AWS Region that contains
	// the source DB instance.  <p>You must specify this parameter when you create an
	// encrypted read replica from another AWS Region by using the Amazon RDS API.
	// Don't specify <code>PreSignedUrl</code> when you are creating an encrypted read
	// replica in the same AWS Region.</p> <p>The presigned URL must be a valid request
	// for the <code>CreateDBInstanceReadReplica</code> API action that can be executed
	// in the source AWS Region that contains the encrypted source DB instance. The
	// presigned URL request must contain the following parameter values: </p> <ul>
	// <li> <p> <code>DestinationRegion</code> - The AWS Region that the encrypted read
	// replica is created in. This AWS Region is the same one where the
	// <code>CreateDBInstanceReadReplica</code> action is called that contains this
	// presigned URL.</p> <p>For example, if you create an encrypted DB instance in the
	// us-west-1 AWS Region, from a source DB instance in the us-east-2 AWS Region,
	// then you call the <code>CreateDBInstanceReadReplica</code> action in the
	// us-east-1 AWS Region and provide a presigned URL that contains a call to the
	// <code>CreateDBInstanceReadReplica</code> action in the us-west-2 AWS Region. For
	// this example, the <code>DestinationRegion</code> in the presigned URL must be
	// set to the us-east-1 AWS Region. </p> </li> <li> <p> <code>KmsKeyId</code> - The
	// AWS KMS key identifier for the key to use to encrypt the read replica in the
	// destination AWS Region. This is the same identifier for both the
	// <code>CreateDBInstanceReadReplica</code> action that is called in the
	// destination AWS Region, and the action contained in the presigned URL. </p>
	// </li> <li> <p> <code>SourceDBInstanceIdentifier</code> - The DB instance
	// identifier for the encrypted DB instance to be replicated. This identifier must
	// be in the Amazon Resource Name (ARN) format for the source AWS Region. For
	// example, if you are creating an encrypted read replica from a DB instance in the
	// us-west-2 AWS Region, then your <code>SourceDBInstanceIdentifier</code> looks
	// like the following example:
	// <code>arn:aws:rds:us-west-2:123456789012:instance:mysql-instance1-20161115</code>.
	// </p> </li> </ul> <p>To learn how to generate a Signature Version 4 signed
	// request, see <a
	// href="https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html">Authenticating
	// Requests: Using Query Parameters (AWS Signature Version 4)</a> and <a
	// href="https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html">Signature
	// Version 4 Signing Process</a>. </p> <note> <p>If you are using an AWS SDK tool
	// or the AWS CLI, you can specify <code>SourceRegion</code> (or
	// <code>--source-region</code> for the AWS CLI) instead of specifying
	// <code>PreSignedUrl</code> manually. Specifying <code>SourceRegion</code>
	// autogenerates a presigned URL that is a valid request for the operation that can
	// be executed in the source AWS Region.</p> <p> <code>SourceRegion</code> isn't
	// supported for SQL Server, because SQL Server on Amazon RDS doesn't support
	// cross-region read replicas.</p> </note>
	PreSignedUrl *string
	// A list of EC2 VPC security groups to associate with the read replica. Default:
	// The default EC2 VPC security group for the DB subnet group's VPC.
	VpcSecurityGroupIds []*string
	// A value that indicates whether the DB instance class of the DB instance uses its
	// default processor features.
	UseDefaultProcessorFeatures *bool
	// The ARN for the IAM role that permits RDS to send enhanced monitoring metrics to
	// Amazon CloudWatch Logs. For example, arn:aws:iam:123456789012:role/emaccess. For
	// information on creating a monitoring role, go to To create an IAM role for
	// Amazon RDS Enhanced Monitoring
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Monitoring.html#USER_Monitoring.OS.IAMRole)
	// in the Amazon RDS User Guide. If MonitoringInterval is set to a value other than
	// 0, then you must supply a MonitoringRoleArn value.
	MonitoringRoleArn *string
	// A value that indicates whether to enable Performance Insights for the read
	// replica. For more information, see Using Amazon Performance Insights
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_PerfInsights.html)
	// in the Amazon RDS User Guide.
	EnablePerformanceInsights *bool
	// A value that indicates whether the read replica is in a Multi-AZ deployment.
	// <p>You can create a read replica as a Multi-AZ DB instance. RDS creates a
	// standby of your replica in another Availability Zone for failover support for
	// the replica. Creating your read replica as a Multi-AZ DB instance is independent
	// of whether the source database is a Multi-AZ DB instance. </p>
	MultiAZ *bool
	// Specifies a DB subnet group for the DB instance. The new DB instance is created
	// in the VPC associated with the DB subnet group. If no DB subnet group is
	// specified, then the new DB instance isn't created in a VPC. Constraints:
	//
	//     *
	// Can only be specified if the source DB instance identifier specifies a DB
	// instance in another AWS Region.
	//
	//     * If supplied, must match the name of an
	// existing DBSubnetGroup.
	//
	//     * The specified DB subnet group must be in the same
	// AWS Region in which the operation is running.
	//
	//     * All read replicas in one
	// AWS Region that are created from the same source DB instance must either:>
	//
	//
	// * Specify DB subnet groups from the same VPC. All these read replicas are
	// created in the same VPC.
	//
	//         * Not specify a DB subnet group. All these
	// read replicas are created outside of any VPC.
	//
	// Example: mySubnetgroup
	DBSubnetGroupName *string
	// The compute and memory capacity of the read replica, for example, db.m4.large.
	// Not all DB instance classes are available in all AWS Regions, or for all
	// database engines. For the full list of DB instance classes, and availability for
	// your engine, see DB Instance Class
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.DBInstanceClass.html)
	// in the Amazon RDS User Guide. Default: Inherits from the source DB instance.
	DBInstanceClass *string
	// A value that indicates whether minor engine upgrades are applied automatically
	// to the read replica during the maintenance window. Default: Inherits from the
	// source DB instance
	AutoMinorVersionUpgrade *bool
	// The name of the DB parameter group to associate with this DB instance. If you do
	// not specify a value for DBParameterGroupName, then Amazon RDS uses the
	// DBParameterGroup of source DB instance for a same region read replica, or the
	// default DBParameterGroup for the specified DB engine for a cross region read
	// replica. Currently, specifying a parameter group for this operation is only
	// supported for Oracle DB instances. Constraints:
	//
	//     * Must be 1 to 255 letters,
	// numbers, or hyphens.
	//
	//     * First character must be a letter
	//
	//     * Can't end
	// with a hyphen or contain two consecutive hyphens
	DBParameterGroupName *string
	// The interval, in seconds, between points when Enhanced Monitoring metrics are
	// collected for the read replica. To disable collecting Enhanced Monitoring
	// metrics, specify 0. The default is 0. If MonitoringRoleArn is specified, then
	// you must also set MonitoringInterval to a value other than 0. Valid Values: 0,
	// 1, 5, 10, 15, 30, 60
	MonitoringInterval *int32
	// The amount of Provisioned IOPS (input/output operations per second) to be
	// initially allocated for the DB instance.
	Iops *int32
	// A value that indicates whether the DB instance is publicly accessible. When the
	// DB instance is publicly accessible, its DNS endpoint resolves to the private IP
	// address from within the DB instance's VPC, and to the public IP address from
	// outside of the DB instance's VPC. Access to the DB instance is ultimately
	// controlled by the security group it uses, and that public access is not
	// permitted if the security group assigned to the DB instance doesn't permit it.
	// When the DB instance isn't publicly accessible, it is an internal DB instance
	// with a DNS name that resolves to a private IP address. For more information, see
	// CreateDBInstance ().
	PubliclyAccessible *bool
	// A list of tags. For more information, see Tagging Amazon RDS Resources
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Tagging.html) in
	// the Amazon RDS User Guide.
	Tags []*types.Tag
	// The option group the DB instance is associated with. If omitted, the option
	// group associated with the source instance is used. For SQL Server, you must use
	// the option group associated with the source instance.
	OptionGroupName *string
	// The Availability Zone (AZ) where the read replica will be created. Default: A
	// random, system-chosen Availability Zone in the endpoint's AWS Region. Example:
	// us-east-1d
	AvailabilityZone *string
	// A value that indicates whether the DB instance has deletion protection enabled.
	// The database can't be deleted when deletion protection is enabled. By default,
	// deletion protection is disabled. For more information, see  Deleting a DB
	// Instance
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_DeleteInstance.html).
	DeletionProtection *bool
	// The AWS KMS key ID for an encrypted read replica. The KMS key ID is the Amazon
	// Resource Name (ARN), KMS key identifier, or the KMS key alias for the KMS
	// encryption key.  <p>If you create an encrypted read replica in the same AWS
	// Region as the source DB instance, then you do not have to specify a value for
	// this parameter. The read replica is encrypted with the same KMS key as the
	// source DB instance.</p> <p>If you create an encrypted read replica in a
	// different AWS Region, then you must specify a KMS key for the destination AWS
	// Region. KMS encryption keys are specific to the AWS Region that they are created
	// in, and you can't use encryption keys from one AWS Region in another AWS
	// Region.</p> <p>You can't create an encrypted read replica from an unencrypted DB
	// instance.</p>
	KmsKeyId *string
	// A value that indicates whether to enable mapping of AWS Identity and Access
	// Management (IAM) accounts to database accounts. By default, mapping is disabled.
	// For information about the supported DB engines, see CreateDBInstance ().  <p>For
	// more information about IAM database authentication, see <a
	// href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/UsingWithRDS.IAMDBAuth.html">
	// IAM Database Authentication for MySQL and PostgreSQL</a> in the <i>Amazon RDS
	// User Guide.</i> </p>
	EnableIAMDatabaseAuthentication *bool
	// The AWS KMS key identifier for encryption of Performance Insights data. The KMS
	// key ID is the Amazon Resource Name (ARN), KMS key identifier, or the KMS key
	// alias for the KMS encryption key. If you do not specify a value for
	// PerformanceInsightsKMSKeyId, then Amazon RDS uses your default encryption key.
	// AWS KMS creates the default encryption key for your AWS account. Your AWS
	// account has a different default encryption key for each AWS Region.
	PerformanceInsightsKMSKeyId *string
	// Specify the name of the IAM role to be used when making API calls to the
	// Directory Service.
	DomainIAMRoleName *string
	// The Active Directory directory ID to create the DB instance in. For Oracle DB
	// instances, Amazon RDS can use Kerberos authentication to authenticate users that
	// connect to the DB instance. For more information, see  Using Kerberos
	// Authentication with Amazon RDS for Oracle
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/oracle-kerberos.html) in
	// the Amazon RDS User Guide. For Microsoft SQL Server DB instances, Amazon RDS can
	// use Windows Authentication to authenticate users that connect to the DB
	// instance. For more information, see  Using Windows Authentication with an Amazon
	// RDS DB Instance Running Microsoft SQL Server
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_SQLServerWinAuth.html)
	// in the Amazon RDS User Guide.
	Domain *string
	// The list of logs that the new DB instance is to export to CloudWatch Logs. The
	// values in the list depend on the DB engine being used. For more information, see
	// Publishing Database Logs to Amazon CloudWatch Logs
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_LogAccess.html#USER_LogAccess.Procedural.UploadtoCloudWatch)
	// in the Amazon RDS User Guide.
	EnableCloudwatchLogsExports []*string
	// The amount of time, in days, to retain Performance Insights data. Valid values
	// are 7 or 731 (2 years).
	PerformanceInsightsRetentionPeriod *int32
	// The number of CPU cores and the number of threads per core for the DB instance
	// class of the DB instance.
	ProcessorFeatures []*types.ProcessorFeature
	// The port number that the DB instance uses for connections. Default: Inherits
	// from the source DB instance Valid Values: 1150-65535
	Port *int32
	// Specifies the storage type to be associated with the read replica. Valid values:
	// standard | gp2 | io1 If you specify io1, you must also include a value for the
	// Iops parameter. Default: io1 if the Iops parameter is specified, otherwise gp2
	StorageType *string
	// The DB instance identifier of the read replica. This identifier is the unique
	// key that identifies a DB instance. This parameter is stored as a lowercase
	// string.
	DBInstanceIdentifier *string
	// The identifier of the DB instance that will act as the source for the read
	// replica. Each DB instance can have up to five read replicas. Constraints:
	//
	//     *
	// Must be the identifier of an existing MySQL, MariaDB, Oracle, PostgreSQL, or SQL
	// Server DB instance.
	//
	//     * Can specify a DB instance that is a MySQL read
	// replica only if the source is running MySQL 5.6 or later.
	//
	//     * For the
	// limitations of Oracle read replicas, see Read Replica Limitations with Oracle
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/oracle-read-replicas.html)
	// in the Amazon RDS User Guide.
	//
	//     * For the limitations of SQL Server read
	// replicas, see Read Replica Limitations with Microsoft SQL Server
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/SQLServer.ReadReplicas.Limitations.html)
	// in the Amazon RDS User Guide.
	//
	//     * Can specify a PostgreSQL DB instance only
	// if the source is running PostgreSQL 9.3.5 or later (9.4.7 and higher for
	// cross-region replication).
	//
	//     * The specified DB instance must have automatic
	// backups enabled, that is, its backup retention period must be greater than 0.
	//
	//
	// * If the source DB instance is in the same AWS Region as the read replica,
	// specify a valid DB instance identifier.
	//
	//     * If the source DB instance is in a
	// different AWS Region from the read replica, specify a valid DB instance ARN. For
	// more information, see Constructing an ARN for Amazon RDS
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Tagging.ARN.html#USER_Tagging.ARN.Constructing)
	// in the Amazon RDS User Guide. This doesn't apply to SQL Server, which doesn't
	// support cross-region replicas.
	SourceDBInstanceIdentifier *string
}

type CreateDBInstanceReadReplicaOutput struct {
	// Contains the details of an Amazon RDS DB instance. This data type is used as a
	// response element in the DescribeDBInstances action.
	DBInstance *types.DBInstance

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateDBParameterGroupInput struct {
	// The DB parameter group family name. A DB parameter group can be associated with
	// one and only one DB parameter group family, and can be applied only to a DB
	// instance running a database engine and engine version compatible with that DB
	// parameter group family. To list all of the available parameter group families,
	// use the following command: aws rds describe-db-engine-versions --query
	// "DBEngineVersions[].DBParameterGroupFamily" The output contains duplicates.
	DBParameterGroupFamily *string
	// Tags to assign to the DB parameter group.
	Tags []*types.Tag
	// The name of the DB parameter group. Constraints:
	//
	//     * Must be 1 to 255
	// letters, numbers, or hyphens.
	//
	//     * First character must be a letter
	//
	//     *
	// Can't end with a hyphen or contain two consecutive hyphens
	//
	// This value is stored
	// as a lowercase string.
	DBParameterGroupName *string
	// The description for the DB parameter group.
	Description *string
}

type CreateDBParameterGroupOutput struct {
	// Contains the details of an Amazon RDS DB parameter group. This data type is used
	// as a response element in the DescribeDBParameterGroups action.
	DBParameterGroup *types.DBParameterGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateDBProxyInput struct {
	// The identifier for the proxy. This name must be unique for all proxies owned by
	// your AWS account in the specified AWS Region. An identifier must begin with a
	// letter and must contain only ASCII letters, digits, and hyphens; it can't end
	// with a hyphen or contain two consecutive hyphens.
	DBProxyName *string
	// The Amazon Resource Name (ARN) of the IAM role that the proxy uses to access
	// secrets in AWS Secrets Manager.
	RoleArn *string
	// The number of seconds that a connection to the proxy can be inactive before the
	// proxy disconnects it. You can set this value higher or lower than the connection
	// timeout limit for the associated database.
	IdleClientTimeout *int32
	// One or more VPC subnet IDs to associate with the new proxy.
	VpcSubnetIds []*string
	// A Boolean parameter that specifies whether Transport Layer Security (TLS)
	// encryption is required for connections to the proxy. By enabling this setting,
	// you can enforce encrypted TLS connections to the proxy.
	RequireTLS *bool
	// An optional set of key-value pairs to associate arbitrary data of your choosing
	// with the proxy.
	Tags []*types.Tag
	// The kinds of databases that the proxy can connect to. This value determines
	// which database network protocol the proxy recognizes when it interprets network
	// traffic to and from the database. The engine family applies to MySQL and
	// PostgreSQL for both RDS and Aurora.
	EngineFamily types.EngineFamily
	// Whether the proxy includes detailed information about SQL statements in its
	// logs. This information helps you to debug issues involving SQL behavior or the
	// performance and scalability of the proxy connections. The debug information
	// includes the text of SQL statements that you submit through the proxy. Thus,
	// only enable this setting when needed for debugging, and only when you have
	// security measures in place to safeguard any sensitive information that appears
	// in the logs.
	DebugLogging *bool
	// The authorization mechanism that the proxy uses.
	Auth []*types.UserAuthConfig
	// One or more VPC security group IDs to associate with the new proxy.
	VpcSecurityGroupIds []*string
}

type CreateDBProxyOutput struct {
	// The DBProxy structure corresponding to the new proxy.
	DBProxy *types.DBProxy

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateDBSecurityGroupInput struct {
	// Tags to assign to the DB security group.
	Tags []*types.Tag
	// The description for the DB security group.
	DBSecurityGroupDescription *string
	// The name for the DB security group. This value is stored as a lowercase string.
	// Constraints:
	//
	//     * Must be 1 to 255 letters, numbers, or hyphens.
	//
	//     * First
	// character must be a letter
	//
	//     * Can't end with a hyphen or contain two
	// consecutive hyphens
	//
	//     * Must not be "Default"
	//
	// Example: mysecuritygroup
	DBSecurityGroupName *string
}

type CreateDBSecurityGroupOutput struct {
	// Contains the details for an Amazon RDS DB security group. This data type is used
	// as a response element in the DescribeDBSecurityGroups action.
	DBSecurityGroup *types.DBSecurityGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateDBSnapshotInput struct {
	// The identifier of the DB instance that you want to create the snapshot of.
	// Constraints:
	//
	//     * Must match the identifier of an existing DBInstance.
	DBInstanceIdentifier *string
	// A list of tags. For more information, see Tagging Amazon RDS Resources
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Tagging.html) in
	// the Amazon RDS User Guide.
	Tags []*types.Tag
	// The identifier for the DB snapshot. Constraints:
	//
	//     * Can't be null, empty, or
	// blank
	//
	//     * Must contain from 1 to 255 letters, numbers, or hyphens
	//
	//     *
	// First character must be a letter
	//
	//     * Can't end with a hyphen or contain two
	// consecutive hyphens
	//
	// Example: my-snapshot-id
	DBSnapshotIdentifier *string
}

type CreateDBSnapshotOutput struct {
	// Contains the details of an Amazon RDS DB snapshot. This data type is used as a
	// response element in the DescribeDBSnapshots action.
	DBSnapshot *types.DBSnapshot

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateDBSubnetGroupInput struct {
	// The name for the DB subnet group. This value is stored as a lowercase string.
	// Constraints: Must contain no more than 255 letters, numbers, periods,
	// underscores, spaces, or hyphens. Must not be default. Example: mySubnetgroup
	DBSubnetGroupName *string
	// The description for the DB subnet group.
	DBSubnetGroupDescription *string
	// The EC2 Subnet IDs for the DB subnet group.
	SubnetIds []*string
	// Tags to assign to the DB subnet group.
	Tags []*types.Tag
}

type CreateDBSubnetGroupOutput struct {
	// Contains the details of an Amazon RDS DB subnet group. This data type is used as
	// a response element in the DescribeDBSubnetGroups action.
	DBSubnetGroup *types.DBSubnetGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateEventSubscriptionInput struct {
	// A value that indicates whether to activate the subscription. If the event
	// notification subscription isn't activated, the subscription is created but not
	// active.
	Enabled *bool
	// The Amazon Resource Name (ARN) of the SNS topic created for event notification.
	// The ARN is created by Amazon SNS when you create a topic and subscribe to it.
	SnsTopicArn *string
	// The list of identifiers of the event sources for which events are returned. If
	// not specified, then all sources are included in the response. An identifier must
	// begin with a letter and must contain only ASCII letters, digits, and hyphens. It
	// can't end with a hyphen or contain two consecutive hyphens. Constraints:
	//
	//     *
	// If SourceIds are supplied, SourceType must also be provided.
	//
	//     * If the
	// source type is a DB instance, then a DBInstanceIdentifier must be supplied.
	//
	//
	// * If the source type is a DB security group, a DBSecurityGroupName must be
	// supplied.
	//
	//     * If the source type is a DB parameter group, a
	// DBParameterGroupName must be supplied.
	//
	//     * If the source type is a DB
	// snapshot, a DBSnapshotIdentifier must be supplied.
	SourceIds []*string
	// A list of tags. For more information, see Tagging Amazon RDS Resources
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Tagging.html) in
	// the Amazon RDS User Guide.
	Tags []*types.Tag
	// The name of the subscription. Constraints: The name must be less than 255
	// characters.
	SubscriptionName *string
	// A list of event categories for a SourceType that you want to subscribe to. You
	// can see a list of the categories for a given SourceType in the Events
	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Events.html) topic
	// in the Amazon RDS User Guide or by using the DescribeEventCategories action.
	EventCategories []*string
	// The type of source that is generating the events. For example, if you want to be
	// notified of events generated by a DB instance, you would set this parameter to
	// db-instance. if this value isn't specified, all events are returned. Valid
	// values: db-instance | db-cluster | db-parameter-group | db-security-group |
	// db-snapshot | db-cluster-snapshot
	SourceType *string
}

type CreateEventSubscriptionOutput struct {
	// Contains the results of a successful invocation of the
	// DescribeEventSubscriptions action.
	EventSubscription *types.EventSubscription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateGlobalClusterInput struct {
	// The name for your database of up to 64 alpha-numeric characters. If you do not
	// provide a name, Amazon Aurora will not create a database in the global database
	// cluster you are creating.
	DatabaseName *string
	// The deletion protection setting for the new global database. The global database
	// can't be deleted when deletion protection is enabled.
	DeletionProtection *bool
	// Provides the name of the database engine to be used for this DB cluster.
	Engine *string
	// The storage encryption setting for the new global database cluster.
	StorageEncrypted *bool
	// The engine version of the Aurora global database.
	EngineVersion *string
	// The Amazon Resource Name (ARN) to use as the primary cluster of the global
	// database. This parameter is optional.
	SourceDBClusterIdentifier *string
	// The cluster identifier of the new global database cluster.
	GlobalClusterIdentifier *string
}

type CreateGlobalClusterOutput struct {
	// A data type representing an Aurora global database.
	GlobalCluster *types.GlobalCluster

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateOptionGroupInput struct {
	// Specifies the name of the option group to be created. Constraints:
	//
	//     * Must
	// be 1 to 255 letters, numbers, or hyphens
	//
	//     * First character must be a
	// letter
	//
	//     * Can't end with a hyphen or contain two consecutive
	// hyphens
	//
	// Example: myoptiongroup
	OptionGroupName *string
	// Specifies the name of the engine that this option group should be associated
	// with.
	EngineName *string
	// The description of the option group.
	OptionGroupDescription *string
	// Tags to assign to the option group.
	Tags []*types.Tag
	// Specifies the major version of the engine that this option group should be
	// associated with.
	MajorEngineVersion *string
}

type CreateOptionGroupOutput struct {
	//
	OptionGroup *types.OptionGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteCustomAvailabilityZoneInput struct {
	// The custom AZ identifier.
	CustomAvailabilityZoneId *string
}

type DeleteCustomAvailabilityZoneOutput struct {
	// A custom Availability Zone (AZ) is an on-premises AZ that is integrated with a
	// VMware vSphere cluster. For more information about RDS on VMware, see the  RDS
	// on VMware User Guide.
	// (https://docs.aws.amazon.com/AmazonRDS/latest/RDSonVMwareUserGuide/rds-on-vmware.html)
	CustomAvailabilityZone *types.CustomAvailabilityZone

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteDBClusterEndpointInput struct {
	// The identifier associated with the custom endpoint. This parameter is stored as
	// a lowercase string.
	DBClusterEndpointIdentifier *string
}

type DeleteDBClusterEndpointOutput struct {
	// The identifier associated with the endpoint. This parameter is stored as a
	// lowercase string.
	DBClusterEndpointIdentifier *string
	// The DB cluster identifier of the DB cluster associated with the endpoint. This
	// parameter is stored as a lowercase string.
	DBClusterIdentifier *string
	// The type of the endpoint. One of: READER, WRITER, CUSTOM.
	EndpointType *string
	// The DNS address of the endpoint.
	Endpoint *string
	// A unique system-generated identifier for an endpoint. It remains the same for
	// the whole life of the endpoint.
	DBClusterEndpointResourceIdentifier *string
	// List of DB instance identifiers that aren't part of the custom endpoint group.
	// All other eligible instances are reachable through the custom endpoint. Only
	// relevant if the list of static members is empty.
	ExcludedMembers []*string
	// The current status of the endpoint. One of: creating, available, deleting,
	// modifying.
	Status *string
	// The Amazon Resource Name (ARN) for the endpoint.
	DBClusterEndpointArn *string
	// The type associated with a custom endpoint. One of: READER, WRITER, ANY.
	CustomEndpointType *string
	// List of DB instance identifiers that are part of the custom endpoint group.
	StaticMembers []*string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteDBClusterInput struct {
	// The DB cluster snapshot identifier of the new DB cluster snapshot created when
	// SkipFinalSnapshot is disabled. Specifying this parameter and also skipping the
	// creation of a final DB cluster snapshot with the SkipFinalShapshot parameter
	// results in an error. Constraints:
	//
	//     * Must be 1 to 255 letters, numbers, or
	// hyphens.
	//
	//     * First character must be a letter
	//
	//     * Can't end with a hyphen
	// or contain two consecutive hyphens
	FinalDBSnapshotIdentifier *string
	// The DB cluster identifier for the DB cluster to be deleted. This parameter isn't
	// case-sensitive. Constraints:
	//
	//     * Must match an existing DBClusterIdentifier.
	DBClusterIdentifier *string
	// A value that indicates whether to skip the creation of a final DB cluster
	// snapshot before the DB cluster is deleted. If skip is specified, no DB cluster
	// snapshot is created. If skip isn't specified, a DB cluster snapshot is created
	// before the DB cluster is deleted. By default, skip isn't specified, and the DB
	// cluster snapshot is created. By default, this parameter is disabled. You must
	// specify a FinalDBSnapshotIdentifier parameter if SkipFinalSnapshot is disabled.
	SkipFinalSnapshot *bool
}

type DeleteDBClusterOutput struct {
	// Contains the details of an Amazon Aurora DB cluster. This data type is used as a
	// response element in the DescribeDBClusters, StopDBCluster, and StartDBCluster
	// actions.
	DBCluster *types.DBCluster

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteDBClusterParameterGroupInput struct {
	// The name of the DB cluster parameter group. Constraints:
	//
	//     * Must be the name
	// of an existing DB cluster parameter group.
	//
	//     * You can't delete a default DB
	// cluster parameter group.
	//
	//     * Can't be associated with any DB clusters.
	DBClusterParameterGroupName *string
}

type DeleteDBClusterParameterGroupOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteDBClusterSnapshotInput struct {
	// The identifier of the DB cluster snapshot to delete. Constraints: Must be the
	// name of an existing DB cluster snapshot in the available state.
	DBClusterSnapshotIdentifier *string
}

type DeleteDBClusterSnapshotOutput struct {
	// Contains the details for an Amazon RDS DB cluster snapshot This data type is
	// used as a response element in the DescribeDBClusterSnapshots action.
	DBClusterSnapshot *types.DBClusterSnapshot

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteDBInstanceAutomatedBackupInput struct {
	// The identifier for the source DB instance, which can't be changed and which is
	// unique to an AWS Region.
	DbiResourceId *string
}

type DeleteDBInstanceAutomatedBackupOutput struct {
	// An automated backup of a DB instance. It it consists of system backups,
	// transaction logs, and the database instance properties that existed at the time
	// you deleted the source instance.
	DBInstanceAutomatedBackup *types.DBInstanceAutomatedBackup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteDBInstanceInput struct {
	// The DB instance identifier for the DB instance to be deleted. This parameter
	// isn't case-sensitive. Constraints:
	//
	//     * Must match the name of an existing DB
	// instance.
	DBInstanceIdentifier *string
	// A value that indicates whether to skip the creation of a final DB snapshot
	// before the DB instance is deleted. If skip is specified, no DB snapshot is
	// created. If skip isn't specified, a DB snapshot is created before the DB
	// instance is deleted. By default, skip isn't specified, and the DB snapshot is
	// created. When a DB instance is in a failure state and has a status of 'failed',
	// 'incompatible-restore', or 'incompatible-network', it can only be deleted when
	// skip is specified. Specify skip when deleting a read replica. The
	// FinalDBSnapshotIdentifier parameter must be specified if skip isn't specified.
	SkipFinalSnapshot *bool
	// A value that indicates whether to remove automated backups immediately after the
	// DB instance is deleted. This parameter isn't case-sensitive. The default is to
	// remove automated backups immediately after the DB instance is deleted.
	DeleteAutomatedBackups *bool
	// The DBSnapshotIdentifier of the new DBSnapshot created when the
	// SkipFinalSnapshot parameter is disabled. Specifying this parameter and also
	// specifying to skip final DB snapshot creation in SkipFinalShapshot results in an
	// error. Constraints:
	//
	//     * Must be 1 to 255 letters or numbers.
	//
	//     * First
	// character must be a letter.
	//
	//     * Can't end with a hyphen or contain two
	// consecutive hyphens.
	//
	//     * Can't be specified when deleting a read replica.
	FinalDBSnapshotIdentifier *string
}

type DeleteDBInstanceOutput struct {
	// Contains the details of an Amazon RDS DB instance. This data type is used as a
	// response element in the DescribeDBInstances action.
	DBInstance *types.DBInstance

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteDBParameterGroupInput struct {
	// The name of the DB parameter group. Constraints:
	//
	//     * Must be the name of an
	// existing DB parameter group
	//
	//     * You can't delete a default DB parameter
	// group
	//
	//     * Can't be associated with any DB instances
	DBParameterGroupName *string
}

type DeleteDBParameterGroupOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteDBProxyInput struct {
	// The name of the DB proxy to delete.
	DBProxyName *string
}

type DeleteDBProxyOutput struct {
	// The data structure representing the details of the DB proxy that you delete.
	DBProxy *types.DBProxy

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteDBSecurityGroupInput struct {
	// The name of the DB security group to delete. You can't delete the default DB
	// security group. Constraints:
	//
	//     * Must be 1 to 255 letters, numbers, or
	// hyphens.
	//
	//     * First character must be a letter
	//
	//     * Can't end with a hyphen
	// or contain two consecutive hyphens
	//
	//     * Must not be "Default"
	DBSecurityGroupName *string
}

type DeleteDBSecurityGroupOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteDBSnapshotInput struct {
	// The DB snapshot identifier. Constraints: Must be the name of an existing DB
	// snapshot in the available state.
	DBSnapshotIdentifier *string
}

type DeleteDBSnapshotOutput struct {
	// Contains the details of an Amazon RDS DB snapshot. This data type is used as a
	// response element in the DescribeDBSnapshots action.
	DBSnapshot *types.DBSnapshot

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteDBSubnetGroupInput struct {
	// The name of the database subnet group to delete. You can't delete the default
	// subnet group. Constraints: Constraints: Must match the name of an existing
	// DBSubnetGroup. Must not be default. Example: mySubnetgroup
	DBSubnetGroupName *string
}

type DeleteDBSubnetGroupOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteEventSubscriptionInput struct {
	// The name of the RDS event notification subscription you want to delete.
	SubscriptionName *string
}

type DeleteEventSubscriptionOutput struct {
	// Contains the results of a successful invocation of the
	// DescribeEventSubscriptions action.
	EventSubscription *types.EventSubscription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteGlobalClusterInput struct {
	// The cluster identifier of the global database cluster being deleted.
	GlobalClusterIdentifier *string
}

type DeleteGlobalClusterOutput struct {
	// A data type representing an Aurora global database.
	GlobalCluster *types.GlobalCluster

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteInstallationMediaInput struct {
	// The installation medium ID.
	InstallationMediaId *string
}

type DeleteInstallationMediaOutput struct {
	// The status of the installation medium.
	Status *string
	// The engine version of the DB engine.
	EngineVersion *string
	// The custom Availability Zone (AZ) that contains the installation media.
	CustomAvailabilityZoneId *string
	// The path to the installation medium for the operating system associated with the
	// DB engine.
	OSInstallationMediaPath *string
	// The DB engine.
	Engine *string
	// If an installation media failure occurred, the cause of the failure.
	FailureCause *types.InstallationMediaFailureCause
	// The installation medium ID.
	InstallationMediaId *string
	// The path to the installation medium for the DB engine.
	EngineInstallationMediaPath *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteOptionGroupInput struct {
	// The name of the option group to be deleted. You can't delete default option
	// groups.
	OptionGroupName *string
}

type DeleteOptionGroupOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeregisterDBProxyTargetsInput struct {
	// The identifier of the DBProxyTargetGroup.
	TargetGroupName *string
	// One or more DB cluster identifiers.
	DBClusterIdentifiers []*string
	// The identifier of the DBProxy that is associated with the DBProxyTargetGroup.
	DBProxyName *string
	// One or more DB instance identifiers.
	DBInstanceIdentifiers []*string
}

type DeregisterDBProxyTargetsOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeAccountAttributesInput struct {
}

type DescribeAccountAttributesOutput struct {
	// A list of AccountQuota objects. Within this list, each quota has a name, a count
	// of usage toward the quota maximum, and a maximum value for the quota.
	AccountQuotas []*types.AccountQuota

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeCertificatesInput struct {
	// The user-supplied certificate identifier. If this parameter is specified,
	// information for only the identified certificate is returned. This parameter
	// isn't case-sensitive. Constraints:
	//
	//     * Must match an existing
	// CertificateIdentifier.
	CertificateIdentifier *string
	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a pagination token called a marker is
	// included in the response so you can retrieve the remaining results. Default: 100
	// Constraints: Minimum 20, maximum 100.
	MaxRecords *int32
	// This parameter isn't currently supported.
	Filters []*types.Filter
	// An optional pagination token provided by a previous DescribeCertificates
	// request. If this parameter is specified, the response includes only records
	// beyond the marker, up to the value specified by MaxRecords.
	Marker *string
}

type DescribeCertificatesOutput struct {
	// The list of Certificate objects for the AWS account.
	Certificates []*types.Certificate
	// An optional pagination token provided by a previous DescribeCertificates
	// request. If this parameter is specified, the response includes only records
	// beyond the marker, up to the value specified by MaxRecords .
	Marker *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeCustomAvailabilityZonesInput struct {
	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a pagination token called a marker is
	// included in the response so you can retrieve the remaining results. Default: 100
	// Constraints: Minimum 20, maximum 100.
	MaxRecords *int32
	// A filter that specifies one or more custom AZs to describe.
	Filters []*types.Filter
	// An optional pagination token provided by a previous
	// DescribeCustomAvailabilityZones request. If this parameter is specified, the
	// response includes only records beyond the marker, up to the value specified by
	// MaxRecords.
	Marker *string
	// The custom AZ identifier. If this parameter is specified, information from only
	// the specific custom AZ is returned.
	CustomAvailabilityZoneId *string
}

type DescribeCustomAvailabilityZonesOutput struct {
	// An optional pagination token provided by a previous
	// DescribeCustomAvailabilityZones request. If this parameter is specified, the
	// response includes only records beyond the marker, up to the value specified by
	// MaxRecords.
	Marker *string
	// The list of CustomAvailabilityZone () objects for the AWS account.
	CustomAvailabilityZones []*types.CustomAvailabilityZone

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeDBClusterBacktracksInput struct {
	// A filter that specifies one or more DB clusters to describe. Supported filters
	// include the following:
	//
	//     * db-cluster-backtrack-id - Accepts backtrack
	// identifiers. The results list includes information about only the backtracks
	// identified by these identifiers.
	//
	//     * db-cluster-backtrack-status - Accepts
	// any of the following backtrack status values:
	//
	//         * applying
	//
	//         *
	// completed
	//
	//         * failed
	//
	//         * pending
	//
	//     The results list includes
	// information about only the backtracks identified by these values.
	Filters []*types.Filter
	// If specified, this value is the backtrack identifier of the backtrack to be
	// described. Constraints:
	//
	//     * Must contain a valid universally unique
	// identifier (UUID). For more information about UUIDs, see A Universally Unique
	// Identifier (UUID) URN Namespace (http://www.ietf.org/rfc/rfc4122.txt).
	//
	// Example:
	// 123e4567-e89b-12d3-a456-426655440000
	BacktrackIdentifier *string
	// The DB cluster identifier of the DB cluster to be described. This parameter is
	// stored as a lowercase string. Constraints:
	//
	//     * Must contain from 1 to 63
	// alphanumeric characters or hyphens.
	//
	//     * First character must be a letter.
	//
	//
	// * Can't end with a hyphen or contain two consecutive hyphens.
	//
	// Example:
	// my-cluster1
	DBClusterIdentifier *string
	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a pagination token called a marker is
	// included in the response so you can retrieve the remaining results. Default: 100
	// Constraints: Minimum 20, maximum 100.
	MaxRecords *int32
	// An optional pagination token provided by a previous DescribeDBClusterBacktracks
	// request. If this parameter is specified, the response includes only records
	// beyond the marker, up to the value specified by MaxRecords.
	Marker *string
}

type DescribeDBClusterBacktracksOutput struct {
	// A pagination token that can be used in a later DescribeDBClusterBacktracks
	// request.
	Marker *string
	// Contains a list of backtracks for the user.
	DBClusterBacktracks []*types.DBClusterBacktrack

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeDBClusterEndpointsInput struct {
	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a pagination token called a marker is
	// included in the response so you can retrieve the remaining results. Default: 100
	// Constraints: Minimum 20, maximum 100.
	MaxRecords *int32
	// The identifier of the endpoint to describe. This parameter is stored as a
	// lowercase string.
	DBClusterEndpointIdentifier *string
	// The DB cluster identifier of the DB cluster associated with the endpoint. This
	// parameter is stored as a lowercase string.
	DBClusterIdentifier *string
	// A set of name-value pairs that define which endpoints to include in the output.
	// The filters are specified as name-value pairs, in the format
	// Name=endpoint_type,Values=endpoint_type1,endpoint_type2,.... Name can be one of:
	// db-cluster-endpoint-type, db-cluster-endpoint-custom-type,
	// db-cluster-endpoint-id, db-cluster-endpoint-status. Values for the
	// db-cluster-endpoint-type filter can be one or more of: reader, writer, custom.
	// Values for the db-cluster-endpoint-custom-type filter can be one or more of:
	// reader, any. Values for the db-cluster-endpoint-status filter can be one or more
	// of: available, creating, deleting, modifying.
	Filters []*types.Filter
	// An optional pagination token provided by a previous DescribeDBClusterEndpoints
	// request. If this parameter is specified, the response includes only records
	// beyond the marker, up to the value specified by MaxRecords.
	Marker *string
}

type DescribeDBClusterEndpointsOutput struct {
	// An optional pagination token provided by a previous DescribeDBClusterEndpoints
	// request. If this parameter is specified, the response includes only records
	// beyond the marker, up to the value specified by MaxRecords.
	Marker *string
	// Contains the details of the endpoints associated with the cluster and matching
	// any filter conditions.
	DBClusterEndpoints []*types.DBClusterEndpoint

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeDBClusterParameterGroupsInput struct {
	// An optional pagination token provided by a previous
	// DescribeDBClusterParameterGroups request. If this parameter is specified, the
	// response includes only records beyond the marker, up to the value specified by
	// MaxRecords.
	Marker *string
	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a pagination token called a marker is
	// included in the response so you can retrieve the remaining results. Default: 100
	// Constraints: Minimum 20, maximum 100.
	MaxRecords *int32
	// The name of a specific DB cluster parameter group to return details for.
	// Constraints:
	//
	//     * If supplied, must match the name of an existing
	// DBClusterParameterGroup.
	DBClusterParameterGroupName *string
	// This parameter isn't currently supported.
	Filters []*types.Filter
}

type DescribeDBClusterParameterGroupsOutput struct {
	// An optional pagination token provided by a previous
	// DescribeDBClusterParameterGroups request. If this parameter is specified, the
	// response includes only records beyond the marker, up to the value specified by
	// MaxRecords.
	Marker *string
	// A list of DB cluster parameter groups.
	DBClusterParameterGroups []*types.DBClusterParameterGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeDBClusterParametersInput struct {
	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a pagination token called a marker is
	// included in the response so you can retrieve the remaining results. Default: 100
	// Constraints: Minimum 20, maximum 100.
	MaxRecords *int32
	// An optional pagination token provided by a previous DescribeDBClusterParameters
	// request. If this parameter is specified, the response includes only records
	// beyond the marker, up to the value specified by MaxRecords.
	Marker *string
	// A value that indicates to return only parameters for a specific source.
	// Parameter sources can be engine, service, or customer.
	Source *string
	// The name of a specific DB cluster parameter group to return parameter details
	// for. Constraints:
	//
	//     * If supplied, must match the name of an existing
	// DBClusterParameterGroup.
	DBClusterParameterGroupName *string
	// This parameter isn't currently supported.
	Filters []*types.Filter
}

type DescribeDBClusterParametersOutput struct {
	// An optional pagination token provided by a previous DescribeDBClusterParameters
	// request. If this parameter is specified, the response includes only records
	// beyond the marker, up to the value specified by MaxRecords .
	Marker *string
	// Provides a list of parameters for the DB cluster parameter group.
	Parameters []*types.Parameter

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeDBClusterSnapshotAttributesInput struct {
	// The identifier for the DB cluster snapshot to describe the attributes for.
	DBClusterSnapshotIdentifier *string
}

type DescribeDBClusterSnapshotAttributesOutput struct {
	// Contains the results of a successful call to the
	// DescribeDBClusterSnapshotAttributes API action. Manual DB cluster snapshot
	// attributes are used to authorize other AWS accounts to copy or restore a manual
	// DB cluster snapshot. For more information, see the
	// ModifyDBClusterSnapshotAttribute API action.
	DBClusterSnapshotAttributesResult *types.DBClusterSnapshotAttributesResult

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeDBClusterSnapshotsInput struct {
	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a pagination token called a marker is
	// included in the response so you can retrieve the remaining results. Default: 100
	// Constraints: Minimum 20, maximum 100.
	MaxRecords *int32
	// A specific DB cluster snapshot identifier to describe. This parameter can't be
	// used in conjunction with the DBClusterIdentifier parameter. This value is stored
	// as a lowercase string. Constraints:
	//
	//     * If supplied, must match the
	// identifier of an existing DBClusterSnapshot.
	//
	//     * If this identifier is for an
	// automated snapshot, the SnapshotType parameter must also be specified.
	DBClusterSnapshotIdentifier *string
	// The type of DB cluster snapshots to be returned. You can specify one of the
	// following values:
	//
	//     * automated - Return all DB cluster snapshots that have
	// been automatically taken by Amazon RDS for my AWS account.
	//
	//     * manual -
	// Return all DB cluster snapshots that have been taken by my AWS account.
	//
	//     *
	// shared - Return all manual DB cluster snapshots that have been shared to my AWS
	// account.
	//
	//     * public - Return all DB cluster snapshots that have been marked
	// as public.
	//
	// If you don't specify a SnapshotType value, then both automated and
	// manual DB cluster snapshots are returned. You can include shared DB cluster
	// snapshots with these results by enabling the IncludeShared parameter. You can
	// include public DB cluster snapshots with these results by enabling the
	// IncludePublic parameter. The IncludeShared and IncludePublic parameters don't
	// apply for SnapshotType values of manual or automated. The IncludePublic
	// parameter doesn't apply when SnapshotType is set to shared. The IncludeShared
	// parameter doesn't apply when SnapshotType is set to public.
	SnapshotType *string
	// The ID of the DB cluster to retrieve the list of DB cluster snapshots for. This
	// parameter can't be used in conjunction with the DBClusterSnapshotIdentifier
	// parameter. This parameter isn't case-sensitive. Constraints:
	//
	//     * If supplied,
	// must match the identifier of an existing DBCluster.
	DBClusterIdentifier *string
	// A filter that specifies one or more DB cluster snapshots to describe. Supported
	// filters:
	//
	//     * db-cluster-id - Accepts DB cluster identifiers and DB cluster
	// Amazon Resource Names (ARNs).
	//
	//     * db-cluster-snapshot-id - Accepts DB cluster
	// snapshot identifiers.
	//
	//     * snapshot-type - Accepts types of DB cluster
	// snapshots.
	//
	//     * engine - Accepts names of database engines.
	Filters []*types.Filter
	// A value that indicates whether to include manual DB cluster snapshots that are
	// public and can be copied or restored by any AWS account. By default, the public
	// snapshots are not included. You can share a manual DB cluster snapshot as public
	// by using the ModifyDBClusterSnapshotAttribute () API action.
	IncludePublic *bool
	// A value that indicates whether to include shared manual DB cluster snapshots
	// from other AWS accounts that this AWS account has been given permission to copy
	// or restore. By default, these snapshots are not included. You can give an AWS
	// account permission to restore a manual DB cluster snapshot from another AWS
	// account by the ModifyDBClusterSnapshotAttribute API action.
	IncludeShared *bool
	// An optional pagination token provided by a previous DescribeDBClusterSnapshots
	// request. If this parameter is specified, the response includes only records
	// beyond the marker, up to the value specified by MaxRecords.
	Marker *string
}

type DescribeDBClusterSnapshotsOutput struct {
	// An optional pagination token provided by a previous DescribeDBClusterSnapshots
	// request. If this parameter is specified, the response includes only records
	// beyond the marker, up to the value specified by MaxRecords.
	Marker *string
	// Provides a list of DB cluster snapshots for the user.
	DBClusterSnapshots []*types.DBClusterSnapshot

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeDBClustersInput struct {
	// A filter that specifies one or more DB clusters to describe. Supported
	// filters:
	//
	//     * db-cluster-id - Accepts DB cluster identifiers and DB cluster
	// Amazon Resource Names (ARNs). The results list will only include information
	// about the DB clusters identified by these ARNs.
	Filters []*types.Filter
	// Optional Boolean parameter that specifies whether the output includes
	// information about clusters shared from other AWS accounts.
	IncludeShared *bool
	// The user-supplied DB cluster identifier. If this parameter is specified,
	// information from only the specific DB cluster is returned. This parameter isn't
	// case-sensitive. Constraints:
	//
	//     * If supplied, must match an existing
	// DBClusterIdentifier.
	DBClusterIdentifier *string
	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a pagination token called a marker is
	// included in the response so you can retrieve the remaining results. Default: 100
	// Constraints: Minimum 20, maximum 100.
	MaxRecords *int32
	// An optional pagination token provided by a previous DescribeDBClusters request.
	// If this parameter is specified, the response includes only records beyond the
	// marker, up to the value specified by MaxRecords.
	Marker *string
}

type DescribeDBClustersOutput struct {
	// Contains a list of DB clusters for the user.
	DBClusters []*types.DBCluster
	// A pagination token that can be used in a later DescribeDBClusters request.
	Marker *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeDBEngineVersionsInput struct {
	// The database engine version to return. Example: 5.1.49
	EngineVersion *string
	// A value that indicates whether only the default version of the specified engine
	// or engine and major version combination is returned.
	DefaultOnly *bool
	// This parameter isn't currently supported.
	Filters []*types.Filter
	// The maximum number of records to include in the response. If more than the
	// MaxRecords value is available, a pagination token called a marker is included in
	// the response so you can retrieve the remaining results. Default: 100
	// Constraints: Minimum 20, maximum 100.
	MaxRecords *int32
	// The database engine to return.
	Engine *string
	// A value that indicates whether to include engine versions that aren't available
	// in the list. The default is to list only available engine versions.
	IncludeAll *bool
	// An optional pagination token provided by a previous request. If this parameter
	// is specified, the response includes only records beyond the marker, up to the
	// value specified by MaxRecords.
	Marker *string
	// The name of a specific DB parameter group family to return details for.
	// Constraints:
	//
	//     * If supplied, must match an existing DBParameterGroupFamily.
	DBParameterGroupFamily *string
	// A value that indicates whether to list the supported character sets for each
	// engine version. If this parameter is enabled and the requested engine supports
	// the CharacterSetName parameter for CreateDBInstance, the response includes a
	// list of supported character sets for each engine version.
	ListSupportedCharacterSets *bool
	// A value that indicates whether to list the supported time zones for each engine
	// version. If this parameter is enabled and the requested engine supports the
	// TimeZone parameter for CreateDBInstance, the response includes a list of
	// supported time zones for each engine version.
	ListSupportedTimezones *bool
}

type DescribeDBEngineVersionsOutput struct {
	// An optional pagination token provided by a previous request. If this parameter
	// is specified, the response includes only records beyond the marker, up to the
	// value specified by MaxRecords.
	Marker *string
	// A list of DBEngineVersion elements.
	DBEngineVersions []*types.DBEngineVersion

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeDBInstanceAutomatedBackupsInput struct {
	// The pagination token provided in the previous request. If this parameter is
	// specified the response includes only records beyond the marker, up to
	// MaxRecords.
	Marker *string
	// (Optional) The user-supplied instance identifier. If this parameter is
	// specified, it must match the identifier of an existing DB instance. It returns
	// information from the specific DB instance' automated backup. This parameter
	// isn't case-sensitive.
	DBInstanceIdentifier *string
	// The resource ID of the DB instance that is the source of the automated backup.
	// This parameter isn't case-sensitive.
	DbiResourceId *string
	// A filter that specifies which resources to return based on status. Supported
	// filters are the following:
	//
	//     * status
	//
	//         * active - automated backups
	// for current instances
	//
	//         * retained - automated backups for deleted
	// instances
	//
	//         * creating - automated backups that are waiting for the first
	// automated snapshot to be available
	//
	//     * db-instance-id - Accepts DB instance
	// identifiers and Amazon Resource Names (ARNs) for DB instances. The results list
	// includes only information about the DB instance automated backupss identified by
	// these ARNs.
	//
	//     * dbi-resource-id - Accepts DB instance resource identifiers
	// and DB Amazon Resource Names (ARNs) for DB instances. The results list includes
	// only information about the DB instance resources identified by these
	// ARNs.
	//
	// Returns all resources by default. The status for each resource is
	// specified in the response.
	Filters []*types.Filter
	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a pagination token called a marker is
	// included in the response so that you can retrieve the remaining results.
	MaxRecords *int32
}

type DescribeDBInstanceAutomatedBackupsOutput struct {
	// An optional pagination token provided by a previous request. If this parameter
	// is specified, the response includes only records beyond the marker, up to the
	// value specified by MaxRecords .
	Marker *string
	// A list of DBInstanceAutomatedBackup instances.
	DBInstanceAutomatedBackups []*types.DBInstanceAutomatedBackup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeDBInstancesInput struct {
	// The user-supplied instance identifier. If this parameter is specified,
	// information from only the specific DB instance is returned. This parameter isn't
	// case-sensitive. Constraints:
	//
	//     * If supplied, must match the identifier of an
	// existing DBInstance.
	DBInstanceIdentifier *string
	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a pagination token called a marker is
	// included in the response so that you can retrieve the remaining results.
	// Default: 100 Constraints: Minimum 20, maximum 100.
	MaxRecords *int32
	// A filter that specifies one or more DB instances to describe. Supported
	// filters:
	//
	//     * db-cluster-id - Accepts DB cluster identifiers and DB cluster
	// Amazon Resource Names (ARNs). The results list will only include information
	// about the DB instances associated with the DB clusters identified by these
	// ARNs.
	//
	//     * db-instance-id - Accepts DB instance identifiers and DB instance
	// Amazon Resource Names (ARNs). The results list will only include information
	// about the DB instances identified by these ARNs.
	//
	//     * dbi-resource-id -
	// Accepts DB instance resource identifiers. The results list will only include
	// information about the DB instances identified by these DB instance resource
	// identifiers.
	//
	//     * domain - Accepts Active Directory directory IDs. The results
	// list will only include information about the DB instances associated with these
	// domains.
	//
	//     * engine - Accepts engine names. The results list will only
	// include information about the DB instances for these engines.
	Filters []*types.Filter
	// An optional pagination token provided by a previous DescribeDBInstances request.
	// If this parameter is specified, the response includes only records beyond the
	// marker, up to the value specified by MaxRecords.
	Marker *string
}

type DescribeDBInstancesOutput struct {
	// An optional pagination token provided by a previous request. If this parameter
	// is specified, the response includes only records beyond the marker, up to the
	// value specified by MaxRecords .
	Marker *string
	// A list of DBInstance instances.
	DBInstances []*types.DBInstance

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeDBLogFilesInput struct {
	// This parameter isn't currently supported.
	Filters []*types.Filter
	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a pagination token called a marker is
	// included in the response so you can retrieve the remaining results.
	MaxRecords *int32
	// Filters the available log files for files written since the specified date, in
	// POSIX timestamp format with milliseconds.
	FileLastWritten *int64
	// Filters the available log files for log file names that contain the specified
	// string.
	FilenameContains *string
	// The pagination token provided in the previous request. If this parameter is
	// specified the response includes only records beyond the marker, up to
	// MaxRecords.
	Marker *string
	// The customer-assigned name of the DB instance that contains the log files you
	// want to list. Constraints:
	//
	//     * Must match the identifier of an existing
	// DBInstance.
	DBInstanceIdentifier *string
	// Filters the available log files for files larger than the specified size.
	FileSize *int64
}

type DescribeDBLogFilesOutput struct {
	// A pagination token that can be used in a later DescribeDBLogFiles request.
	Marker *string
	// The DB log files returned.
	DescribeDBLogFiles []*types.DescribeDBLogFilesDetails

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeDBParameterGroupsInput struct {
	// An optional pagination token provided by a previous DescribeDBParameterGroups
	// request. If this parameter is specified, the response includes only records
	// beyond the marker, up to the value specified by MaxRecords.
	Marker *string
	// The name of a specific DB parameter group to return details for. Constraints:
	//
	//
	// * If supplied, must match the name of an existing DBClusterParameterGroup.
	DBParameterGroupName *string
	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a pagination token called a marker is
	// included in the response so that you can retrieve the remaining results.
	// Default: 100 Constraints: Minimum 20, maximum 100.
	MaxRecords *int32
	// This parameter isn't currently supported.
	Filters []*types.Filter
}

type DescribeDBParameterGroupsOutput struct {
	// A list of DBParameterGroup instances.
	DBParameterGroups []*types.DBParameterGroup
	// An optional pagination token provided by a previous request. If this parameter
	// is specified, the response includes only records beyond the marker, up to the
	// value specified by MaxRecords.
	Marker *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeDBParametersInput struct {
	// The parameter types to return. Default: All parameter types returned Valid
	// Values: user | system | engine-default
	Source *string
	// This parameter isn't currently supported.
	Filters []*types.Filter
	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a pagination token called a marker is
	// included in the response so that you can retrieve the remaining results.
	// Default: 100 Constraints: Minimum 20, maximum 100.
	MaxRecords *int32
	// The name of a specific DB parameter group to return details for. Constraints:
	//
	//
	// * If supplied, must match the name of an existing DBParameterGroup.
	DBParameterGroupName *string
	// An optional pagination token provided by a previous DescribeDBParameters
	// request. If this parameter is specified, the response includes only records
	// beyond the marker, up to the value specified by MaxRecords.
	Marker *string
}

type DescribeDBParametersOutput struct {
	// A list of Parameter values.
	Parameters []*types.Parameter
	// An optional pagination token provided by a previous request. If this parameter
	// is specified, the response includes only records beyond the marker, up to the
	// value specified by MaxRecords.
	Marker *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeDBProxiesInput struct {
	// This parameter is not currently supported.
	Filters []*types.Filter
	// The name of the DB proxy.
	DBProxyName *string
	// An optional pagination token provided by a previous request. If this parameter
	// is specified, the response includes only records beyond the marker, up to the
	// value specified by MaxRecords.
	Marker *string
	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a pagination token called a marker is
	// included in the response so that the remaining results can be retrieved.
	// Default: 100 Constraints: Minimum 20, maximum 100.
	MaxRecords *int32
}

type DescribeDBProxiesOutput struct {
	// A return value representing an arbitrary number of DBProxy data structures.
	DBProxies []*types.DBProxy
	// An optional pagination token provided by a previous request. If this parameter
	// is specified, the response includes only records beyond the marker, up to the
	// value specified by MaxRecords.
	Marker *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeDBProxyTargetGroupsInput struct {
	// The identifier of the DBProxyTargetGroup to describe.
	TargetGroupName *string
	// This parameter is not currently supported.
	Filters []*types.Filter
	// The identifier of the DBProxy associated with the target group.
	DBProxyName *string
	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a pagination token called a marker is
	// included in the response so that the remaining results can be retrieved.
	// Default: 100 Constraints: Minimum 20, maximum 100.
	MaxRecords *int32
	// An optional pagination token provided by a previous request. If this parameter
	// is specified, the response includes only records beyond the marker, up to the
	// value specified by MaxRecords.
	Marker *string
}

type DescribeDBProxyTargetGroupsOutput struct {
	// An optional pagination token provided by a previous request. If this parameter
	// is specified, the response includes only records beyond the marker, up to the
	// value specified by MaxRecords.
	Marker *string
	// An arbitrary number of DBProxyTargetGroup objects, containing details of the
	// corresponding target groups.
	TargetGroups []*types.DBProxyTargetGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeDBProxyTargetsInput struct {
	// The identifier of the DBProxyTargetGroup to describe.
	TargetGroupName *string
	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a pagination token called a marker is
	// included in the response so that the remaining results can be retrieved.
	// Default: 100 Constraints: Minimum 20, maximum 100.
	MaxRecords *int32
	// The identifier of the DBProxyTarget to describe.
	DBProxyName *string
	// An optional pagination token provided by a previous request. If this parameter
	// is specified, the response includes only records beyond the marker, up to the
	// value specified by MaxRecords.
	Marker *string
	// This parameter is not currently supported.
	Filters []*types.Filter
}

type DescribeDBProxyTargetsOutput struct {
	// An optional pagination token provided by a previous request. If this parameter
	// is specified, the response includes only records beyond the marker, up to the
	// value specified by MaxRecords.
	Marker *string
	// An arbitrary number of DBProxyTarget objects, containing details of the
	// corresponding targets.
	Targets []*types.DBProxyTarget

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeDBSecurityGroupsInput struct {
	// An optional pagination token provided by a previous DescribeDBSecurityGroups
	// request. If this parameter is specified, the response includes only records
	// beyond the marker, up to the value specified by MaxRecords.
	Marker *string
	// This parameter isn't currently supported.
	Filters []*types.Filter
	// The name of the DB security group to return details for.
	DBSecurityGroupName *string
	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a pagination token called a marker is
	// included in the response so that you can retrieve the remaining results.
	// Default: 100 Constraints: Minimum 20, maximum 100.
	MaxRecords *int32
}

type DescribeDBSecurityGroupsOutput struct {
	// A list of DBSecurityGroup instances.
	DBSecurityGroups []*types.DBSecurityGroup
	// An optional pagination token provided by a previous request. If this parameter
	// is specified, the response includes only records beyond the marker, up to the
	// value specified by MaxRecords.
	Marker *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeDBSnapshotAttributesInput struct {
	// The identifier for the DB snapshot to describe the attributes for.
	DBSnapshotIdentifier *string
}

type DescribeDBSnapshotAttributesOutput struct {
	// Contains the results of a successful call to the DescribeDBSnapshotAttributes
	// API action. Manual DB snapshot attributes are used to authorize other AWS
	// accounts to copy or restore a manual DB snapshot. For more information, see the
	// ModifyDBSnapshotAttribute API action.
	DBSnapshotAttributesResult *types.DBSnapshotAttributesResult

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeDBSnapshotsInput struct {
	// The type of snapshots to be returned. You can specify one of the following
	// values:
	//
	//     * automated - Return all DB snapshots that have been automatically
	// taken by Amazon RDS for my AWS account.
	//
	//     * manual - Return all DB snapshots
	// that have been taken by my AWS account.
	//
	//     * shared - Return all manual DB
	// snapshots that have been shared to my AWS account.
	//
	//     * public - Return all DB
	// snapshots that have been marked as public.
	//
	//     * awsbackup - Return the DB
	// snapshots managed by the AWS Backup service. For information about AWS Backup,
	// see the  AWS Backup Developer Guide.
	// (https://docs.aws.amazon.com/aws-backup/latest/devguide/whatisbackup.html) The
	// awsbackup type does not apply to Aurora.
	//
	// If you don't specify a SnapshotType
	// value, then both automated and manual snapshots are returned. Shared and public
	// DB snapshots are not included in the returned results by default. You can
	// include shared snapshots with these results by enabling the IncludeShared
	// parameter. You can include public snapshots with these results by enabling the
	// IncludePublic parameter. The IncludeShared and IncludePublic parameters don't
	// apply for SnapshotType values of manual or automated. The IncludePublic
	// parameter doesn't apply when SnapshotType is set to shared. The IncludeShared
	// parameter doesn't apply when SnapshotType is set to public.
	SnapshotType *string
	// An optional pagination token provided by a previous DescribeDBSnapshots request.
	// If this parameter is specified, the response includes only records beyond the
	// marker, up to the value specified by MaxRecords.
	Marker *string
	// A value that indicates whether to include manual DB cluster snapshots that are
	// public and can be copied or restored by any AWS account. By default, the public
	// snapshots are not included. You can share a manual DB snapshot as public by
	// using the ModifyDBSnapshotAttribute () API.
	IncludePublic *bool
	// A value that indicates whether to include shared manual DB cluster snapshots
	// from other AWS accounts that this AWS account has been given permission to copy
	// or restore. By default, these snapshots are not included. You can give an AWS
	// account permission to restore a manual DB snapshot from another AWS account by
	// using the ModifyDBSnapshotAttribute API action.
	IncludeShared *bool
	// A filter that specifies one or more DB snapshots to describe. Supported
	// filters:
	//
	//     * db-instance-id - Accepts DB instance identifiers and DB instance
	// Amazon Resource Names (ARNs).
	//
	//     * db-snapshot-id - Accepts DB snapshot
	// identifiers.
	//
	//     * dbi-resource-id - Accepts identifiers of source DB
	// instances.
	//
	//     * snapshot-type - Accepts types of DB snapshots.
	//
	//     * engine -
	// Accepts names of database engines.
	Filters []*types.Filter
	// A specific DB snapshot identifier to describe. This parameter can't be used in
	// conjunction with DBInstanceIdentifier. This value is stored as a lowercase
	// string. Constraints:
	//
	//     * If supplied, must match the identifier of an
	// existing DBSnapshot.
	//
	//     * If this identifier is for an automated snapshot, the
	// SnapshotType parameter must also be specified.
	DBSnapshotIdentifier *string
	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a pagination token called a marker is
	// included in the response so that you can retrieve the remaining results.
	// Default: 100 Constraints: Minimum 20, maximum 100.
	MaxRecords *int32
	// A specific DB resource ID to describe.
	DbiResourceId *string
	// The ID of the DB instance to retrieve the list of DB snapshots for. This
	// parameter can't be used in conjunction with DBSnapshotIdentifier. This parameter
	// isn't case-sensitive. Constraints:
	//
	//     * If supplied, must match the identifier
	// of an existing DBInstance.
	DBInstanceIdentifier *string
}

type DescribeDBSnapshotsOutput struct {
	// A list of DBSnapshot instances.
	DBSnapshots []*types.DBSnapshot
	// An optional pagination token provided by a previous request. If this parameter
	// is specified, the response includes only records beyond the marker, up to the
	// value specified by MaxRecords.
	Marker *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeDBSubnetGroupsInput struct {
	// This parameter isn't currently supported.
	Filters []*types.Filter
	// The name of the DB subnet group to return details for.
	DBSubnetGroupName *string
	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a pagination token called a marker is
	// included in the response so that you can retrieve the remaining results.
	// Default: 100 Constraints: Minimum 20, maximum 100.
	MaxRecords *int32
	// An optional pagination token provided by a previous DescribeDBSubnetGroups
	// request. If this parameter is specified, the response includes only records
	// beyond the marker, up to the value specified by MaxRecords.
	Marker *string
}

type DescribeDBSubnetGroupsOutput struct {
	// An optional pagination token provided by a previous request. If this parameter
	// is specified, the response includes only records beyond the marker, up to the
	// value specified by MaxRecords.
	Marker *string
	// A list of DBSubnetGroup instances.
	DBSubnetGroups []*types.DBSubnetGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeEngineDefaultClusterParametersInput struct {
	// An optional pagination token provided by a previous
	// DescribeEngineDefaultClusterParameters request. If this parameter is specified,
	// the response includes only records beyond the marker, up to the value specified
	// by MaxRecords.
	Marker *string
	// This parameter isn't currently supported.
	Filters []*types.Filter
	// The name of the DB cluster parameter group family to return engine parameter
	// information for.
	DBParameterGroupFamily *string
	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a pagination token called a marker is
	// included in the response so you can retrieve the remaining results. Default: 100
	// Constraints: Minimum 20, maximum 100.
	MaxRecords *int32
}

type DescribeEngineDefaultClusterParametersOutput struct {
	// Contains the result of a successful invocation of the
	// DescribeEngineDefaultParameters action.
	EngineDefaults *types.EngineDefaults

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeEngineDefaultParametersInput struct {
	// The name of the DB parameter group family.
	DBParameterGroupFamily *string
	// An optional pagination token provided by a previous
	// DescribeEngineDefaultParameters request. If this parameter is specified, the
	// response includes only records beyond the marker, up to the value specified by
	// MaxRecords.
	Marker *string
	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a pagination token called a marker is
	// included in the response so you can retrieve the remaining results. Default: 100
	// Constraints: Minimum 20, maximum 100.
	MaxRecords *int32
	// This parameter isn't currently supported.
	Filters []*types.Filter
}