Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccountQuota

type AccountQuota struct {

	// The name of the Amazon RDS quota for this AWS account.
	AccountQuotaName *string

	// The maximum allowed value for the quota.
	Max int64

	// The amount currently used toward the quota maximum.
	Used int64
}

    Describes a quota for an AWS account. The following are account quotas:

    * AllocatedStorage - The total allocated storage per account, in GiB. The used value is the total allocated storage in the account, in GiB.

    * AuthorizationsPerDBSecurityGroup - The number of ingress rules per DB security group. The used value is the highest number of ingress rules in a DB security group in the account. Other DB security groups in the account might have a lower number of ingress rules.

    * CustomEndpointsPerDBCluster - The number of custom endpoints per DB cluster. The used value is the highest number of custom endpoints in a DB clusters in the account. Other DB clusters in the account might have a lower number of custom endpoints.

    * DBClusterParameterGroups - The number of DB cluster parameter groups per account, excluding default parameter groups. The used value is the count of nondefault DB cluster parameter groups in the account.

    * DBClusterRoles - The number of associated AWS Identity and Access Management (IAM) roles per DB cluster. The used value is the highest number of associated IAM roles for a DB cluster in the account. Other DB clusters in the account might have a lower number of associated IAM roles.

    * DBClusters - The number of DB clusters per account. The used value is the count of DB clusters in the account.

    * DBInstanceRoles - The number of associated IAM roles per DB instance. The used value is the highest number of associated IAM roles for a DB instance in the account. Other DB instances in the account might have a lower number of associated IAM roles.

    * DBInstances - The number of DB instances per account. The used value is the count of the DB instances in the account. Amazon RDS DB instances, Amazon Aurora DB instances, Amazon Neptune instances, and Amazon DocumentDB instances apply to this quota.

    * DBParameterGroups - The number of DB parameter groups per account, excluding default parameter groups. The used value is the count of nondefault DB parameter groups in the account.

    * DBSecurityGroups - The number of DB security groups (not VPC security groups) per account, excluding the default security group. The used value is the count of nondefault DB security groups in the account.

    * DBSubnetGroups - The number of DB subnet groups per account. The used value is the count of the DB subnet groups in the account.

    * EventSubscriptions - The number of event subscriptions per account. The used value is the count of the event subscriptions in the account.

    * ManualClusterSnapshots - The number of manual DB cluster snapshots per account. The used value is the count of the manual DB cluster snapshots in the account.

    * ManualSnapshots - The number of manual DB instance snapshots per account. The used value is the count of the manual DB instance snapshots in the account.

    * OptionGroups - The number of DB option groups per account, excluding default option groups. The used value is the count of nondefault DB option groups in the account.

    * ReadReplicasPerMaster - The number of read replicas per DB instance. The used value is the highest number of read replicas for a DB instance in the account. Other DB instances in the account might have a lower number of read replicas.

    * ReservedDBInstances - The number of reserved DB instances per account. The used value is the count of the active reserved DB instances in the account.

    * SubnetsPerDBSubnetGroup - The number of subnets per DB subnet group. The used value is highest number of subnets for a DB subnet group in the account. Other DB subnet groups in the account might have a lower number of subnets.

    For more information, see Quotas for Amazon RDS (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Limits.html) in the Amazon RDS User Guide and Quotas for Amazon Aurora (https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_Limits.html) in the Amazon Aurora User Guide.

    type ActivityStreamMode

    type ActivityStreamMode string
    const (
    	ActivityStreamModeSync  ActivityStreamMode = "sync"
    	ActivityStreamModeAsync ActivityStreamMode = "async"
    )

      Enum values for ActivityStreamMode

      func (ActivityStreamMode) Values

        Values returns all known values for ActivityStreamMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

        type ActivityStreamStatus

        type ActivityStreamStatus string
        const (
        	ActivityStreamStatusStopped  ActivityStreamStatus = "stopped"
        	ActivityStreamStatusStarting ActivityStreamStatus = "starting"
        	ActivityStreamStatusStarted  ActivityStreamStatus = "started"
        	ActivityStreamStatusStopping ActivityStreamStatus = "stopping"
        )

          Enum values for ActivityStreamStatus

          func (ActivityStreamStatus) Values

            Values returns all known values for ActivityStreamStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

            type ApplyMethod

            type ApplyMethod string
            const (
            	ApplyMethodImmediate     ApplyMethod = "immediate"
            	ApplyMethodPendingReboot ApplyMethod = "pending-reboot"
            )

              Enum values for ApplyMethod

              func (ApplyMethod) Values

              func (ApplyMethod) Values() []ApplyMethod

                Values returns all known values for ApplyMethod. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                type AuthScheme

                type AuthScheme string
                const (
                	AuthSchemeSecrets AuthScheme = "SECRETS"
                )

                  Enum values for AuthScheme

                  func (AuthScheme) Values

                  func (AuthScheme) Values() []AuthScheme

                    Values returns all known values for AuthScheme. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                    type AuthorizationAlreadyExistsFault

                    type AuthorizationAlreadyExistsFault struct {
                    	Message *string
                    }

                      The specified CIDR IP range or Amazon EC2 security group is already authorized for the specified DB security group.

                      func (*AuthorizationAlreadyExistsFault) Error

                      func (*AuthorizationAlreadyExistsFault) ErrorCode

                      func (e *AuthorizationAlreadyExistsFault) ErrorCode() string

                      func (*AuthorizationAlreadyExistsFault) ErrorFault

                      func (*AuthorizationAlreadyExistsFault) ErrorMessage

                      func (e *AuthorizationAlreadyExistsFault) ErrorMessage() string

                      type AuthorizationNotFoundFault

                      type AuthorizationNotFoundFault struct {
                      	Message *string
                      }

                        The specified CIDR IP range or Amazon EC2 security group might not be authorized for the specified DB security group. Or, RDS might not be authorized to perform necessary actions using IAM on your behalf.

                        func (*AuthorizationNotFoundFault) Error

                        func (*AuthorizationNotFoundFault) ErrorCode

                        func (e *AuthorizationNotFoundFault) ErrorCode() string

                        func (*AuthorizationNotFoundFault) ErrorFault

                        func (*AuthorizationNotFoundFault) ErrorMessage

                        func (e *AuthorizationNotFoundFault) ErrorMessage() string

                        type AuthorizationQuotaExceededFault

                        type AuthorizationQuotaExceededFault struct {
                        	Message *string
                        }

                          The DB security group authorization quota has been reached.

                          func (*AuthorizationQuotaExceededFault) Error

                          func (*AuthorizationQuotaExceededFault) ErrorCode

                          func (e *AuthorizationQuotaExceededFault) ErrorCode() string

                          func (*AuthorizationQuotaExceededFault) ErrorFault

                          func (*AuthorizationQuotaExceededFault) ErrorMessage

                          func (e *AuthorizationQuotaExceededFault) ErrorMessage() string

                          type AvailabilityZone

                          type AvailabilityZone struct {
                          
                          	// The name of the Availability Zone.
                          	Name *string
                          }

                            Contains Availability Zone information. This data type is used as an element in the OrderableDBInstanceOption data type.

                            type AvailableProcessorFeature

                            type AvailableProcessorFeature struct {
                            
                            	// The allowed values for the processor feature of the DB instance class.
                            	AllowedValues *string
                            
                            	// The default value for the processor feature of the DB instance class.
                            	DefaultValue *string
                            
                            	// The name of the processor feature. Valid names are coreCount and threadsPerCore.
                            	Name *string
                            }

                              Contains the available processor feature information for the DB instance class of a DB instance. For more information, see Configuring the Processor of the DB Instance Class (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.DBInstanceClass.html#USER_ConfigureProcessor) in the Amazon RDS User Guide.

                              type BackupPolicyNotFoundFault

                              type BackupPolicyNotFoundFault struct {
                              	Message *string
                              }

                              func (*BackupPolicyNotFoundFault) Error

                              func (e *BackupPolicyNotFoundFault) Error() string

                              func (*BackupPolicyNotFoundFault) ErrorCode

                              func (e *BackupPolicyNotFoundFault) ErrorCode() string

                              func (*BackupPolicyNotFoundFault) ErrorFault

                              func (*BackupPolicyNotFoundFault) ErrorMessage

                              func (e *BackupPolicyNotFoundFault) ErrorMessage() string

                              type Certificate

                              type Certificate struct {
                              
                              	// The Amazon Resource Name (ARN) for the certificate.
                              	CertificateArn *string
                              
                              	// The unique key that identifies a certificate.
                              	CertificateIdentifier *string
                              
                              	// The type of the certificate.
                              	CertificateType *string
                              
                              	// Whether there is an override for the default certificate identifier.
                              	CustomerOverride *bool
                              
                              	// If there is an override for the default certificate identifier, when the
                              	// override expires.
                              	CustomerOverrideValidTill *time.Time
                              
                              	// The thumbprint of the certificate.
                              	Thumbprint *string
                              
                              	// The starting date from which the certificate is valid.
                              	ValidFrom *time.Time
                              
                              	// The final date that the certificate continues to be valid.
                              	ValidTill *time.Time
                              }

                                A CA certificate for an AWS account.

                                type CertificateNotFoundFault

                                type CertificateNotFoundFault struct {
                                	Message *string
                                }

                                  CertificateIdentifier doesn't refer to an existing certificate.

                                  func (*CertificateNotFoundFault) Error

                                  func (e *CertificateNotFoundFault) Error() string

                                  func (*CertificateNotFoundFault) ErrorCode

                                  func (e *CertificateNotFoundFault) ErrorCode() string

                                  func (*CertificateNotFoundFault) ErrorFault

                                  func (e *CertificateNotFoundFault) ErrorFault() smithy.ErrorFault

                                  func (*CertificateNotFoundFault) ErrorMessage

                                  func (e *CertificateNotFoundFault) ErrorMessage() string

                                  type CharacterSet

                                  type CharacterSet struct {
                                  
                                  	// The description of the character set.
                                  	CharacterSetDescription *string
                                  
                                  	// The name of the character set.
                                  	CharacterSetName *string
                                  }

                                    This data type is used as a response element in the action DescribeDBEngineVersions.

                                    type CloudwatchLogsExportConfiguration

                                    type CloudwatchLogsExportConfiguration struct {
                                    
                                    	// The list of log types to disable.
                                    	DisableLogTypes []string
                                    
                                    	// The list of log types to enable.
                                    	EnableLogTypes []string
                                    }

                                      The configuration setting for the log types to be enabled for export to CloudWatch Logs for a specific DB instance or DB cluster. The EnableLogTypes and DisableLogTypes arrays determine which logs will be exported (or not exported) to CloudWatch Logs. The values within these arrays depend on the DB engine being used. For more information about exporting CloudWatch Logs for Amazon RDS DB instances, 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. For more information about exporting CloudWatch Logs for Amazon Aurora DB clusters, 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.

                                      type ClusterPendingModifiedValues

                                      type ClusterPendingModifiedValues struct {
                                      
                                      	// The DBClusterIdentifier for the DB cluster.
                                      	DBClusterIdentifier *string
                                      
                                      	// The database engine version.
                                      	EngineVersion *string
                                      
                                      	// Whether mapping of AWS Identity and Access Management (IAM) accounts to database
                                      	// accounts is enabled.
                                      	IAMDatabaseAuthenticationEnabled *bool
                                      
                                      	// The master credentials for the DB cluster.
                                      	MasterUserPassword *string
                                      
                                      	// A list of the log types whose configuration is still pending. In other words,
                                      	// these log types are in the process of being activated or deactivated.
                                      	PendingCloudwatchLogsExports *PendingCloudwatchLogsExports
                                      }

                                        This data type is used as a response element in the ModifyDBCluster operation and contains changes that will be applied during the next maintenance window.

                                        type ConnectionPoolConfiguration

                                        type ConnectionPoolConfiguration struct {
                                        
                                        	// The number of seconds for a proxy to wait for a connection to become available
                                        	// in the connection pool. Only applies when the proxy has opened its maximum
                                        	// number of connections and all connections are busy with client sessions.
                                        	// Default: 120 Constraints: between 1 and 3600, or 0 representing unlimited
                                        	ConnectionBorrowTimeout *int32
                                        
                                        	// One or more SQL statements for the proxy to run when opening each new database
                                        	// connection. Typically used with SET statements to make sure that each connection
                                        	// has identical settings such as time zone and character set. For multiple
                                        	// statements, use semicolons as the separator. You can also include multiple
                                        	// variables in a single SET statement, such as SET x=1, y=2. Default: no
                                        	// initialization query
                                        	InitQuery *string
                                        
                                        	// The maximum size of the connection pool for each target in a target group. For
                                        	// Aurora MySQL, it is expressed as a percentage of the max_connections setting for
                                        	// the RDS DB instance or Aurora DB cluster used by the target group. Default: 100
                                        	// Constraints: between 1 and 100
                                        	MaxConnectionsPercent *int32
                                        
                                        	// Controls how actively the proxy closes idle database connections in the
                                        	// connection pool. A high value enables the proxy to leave a high percentage of
                                        	// idle connections open. A low value causes the proxy to close idle client
                                        	// connections and return the underlying database connections to the connection
                                        	// pool. For Aurora MySQL, it is expressed as a percentage of the max_connections
                                        	// setting for the RDS DB instance or Aurora DB cluster used by the target group.
                                        	// Default: 50 Constraints: between 0 and MaxConnectionsPercent
                                        	MaxIdleConnectionsPercent *int32
                                        
                                        	// Each item in the list represents a class of SQL operations that normally cause
                                        	// all later statements in a session using a proxy to be pinned to the same
                                        	// underlying database connection. Including an item in the list exempts that class
                                        	// of SQL operations from the pinning behavior. Default: no session pinning filters
                                        	SessionPinningFilters []string
                                        }

                                          Specifies the settings that control the size and behavior of the connection pool associated with a DBProxyTargetGroup.

                                          type ConnectionPoolConfigurationInfo

                                          type ConnectionPoolConfigurationInfo struct {
                                          
                                          	// The number of seconds for a proxy to wait for a connection to become available
                                          	// in the connection pool. Only applies when the proxy has opened its maximum
                                          	// number of connections and all connections are busy with client sessions.
                                          	ConnectionBorrowTimeout int32
                                          
                                          	// One or more SQL statements for the proxy to run when opening each new database
                                          	// connection. Typically used with SET statements to make sure that each connection
                                          	// has identical settings such as time zone and character set. This setting is
                                          	// empty by default. For multiple statements, use semicolons as the separator. You
                                          	// can also include multiple variables in a single SET statement, such as SET x=1,
                                          	// y=2.
                                          	InitQuery *string
                                          
                                          	// The maximum size of the connection pool for each target in a target group. For
                                          	// Aurora MySQL, it is expressed as a percentage of the max_connections setting for
                                          	// the RDS DB instance or Aurora DB cluster used by the target group.
                                          	MaxConnectionsPercent int32
                                          
                                          	// Controls how actively the proxy closes idle database connections in the
                                          	// connection pool. A high value enables the proxy to leave a high percentage of
                                          	// idle connections open. A low value causes the proxy to close idle client
                                          	// connections and return the underlying database connections to the connection
                                          	// pool. For Aurora MySQL, it is expressed as a percentage of the max_connections
                                          	// setting for the RDS DB instance or Aurora DB cluster used by the target group.
                                          	MaxIdleConnectionsPercent int32
                                          
                                          	// Each item in the list represents a class of SQL operations that normally cause
                                          	// all later statements in a session using a proxy to be pinned to the same
                                          	// underlying database connection. Including an item in the list exempts that class
                                          	// of SQL operations from the pinning behavior. Currently, the only allowed value
                                          	// is EXCLUDE_VARIABLE_SETS.
                                          	SessionPinningFilters []string
                                          }

                                            Displays the settings that control the size and behavior of the connection pool associated with a DBProxyTarget.

                                            type CustomAvailabilityZone

                                            type CustomAvailabilityZone struct {
                                            
                                            	// The identifier of the custom AZ. Amazon RDS generates a unique identifier when a
                                            	// custom AZ is created.
                                            	CustomAvailabilityZoneId *string
                                            
                                            	// The name of the custom AZ.
                                            	CustomAvailabilityZoneName *string
                                            
                                            	// The status of the custom AZ.
                                            	CustomAvailabilityZoneStatus *string
                                            
                                            	// Information about the virtual private network (VPN) between the VMware vSphere
                                            	// cluster and the AWS website.
                                            	VpnDetails *VpnDetails
                                            }

                                              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)

                                              type CustomAvailabilityZoneAlreadyExistsFault

                                              type CustomAvailabilityZoneAlreadyExistsFault struct {
                                              	Message *string
                                              }

                                                CustomAvailabilityZoneName is already used by an existing custom Availability Zone.

                                                func (*CustomAvailabilityZoneAlreadyExistsFault) Error

                                                func (*CustomAvailabilityZoneAlreadyExistsFault) ErrorCode

                                                func (*CustomAvailabilityZoneAlreadyExistsFault) ErrorFault

                                                func (*CustomAvailabilityZoneAlreadyExistsFault) ErrorMessage

                                                type CustomAvailabilityZoneNotFoundFault

                                                type CustomAvailabilityZoneNotFoundFault struct {
                                                	Message *string
                                                }

                                                  CustomAvailabilityZoneId doesn't refer to an existing custom Availability Zone identifier.

                                                  func (*CustomAvailabilityZoneNotFoundFault) Error

                                                  func (*CustomAvailabilityZoneNotFoundFault) ErrorCode

                                                  func (*CustomAvailabilityZoneNotFoundFault) ErrorFault

                                                  func (*CustomAvailabilityZoneNotFoundFault) ErrorMessage

                                                  func (e *CustomAvailabilityZoneNotFoundFault) ErrorMessage() string

                                                  type CustomAvailabilityZoneQuotaExceededFault

                                                  type CustomAvailabilityZoneQuotaExceededFault struct {
                                                  	Message *string
                                                  }

                                                    You have exceeded the maximum number of custom Availability Zones.

                                                    func (*CustomAvailabilityZoneQuotaExceededFault) Error

                                                    func (*CustomAvailabilityZoneQuotaExceededFault) ErrorCode

                                                    func (*CustomAvailabilityZoneQuotaExceededFault) ErrorFault

                                                    func (*CustomAvailabilityZoneQuotaExceededFault) ErrorMessage

                                                    type DBCluster

                                                    type DBCluster struct {
                                                    
                                                    	// The name of the Amazon Kinesis data stream used for the database activity
                                                    	// stream.
                                                    	ActivityStreamKinesisStreamName *string
                                                    
                                                    	// The AWS KMS key identifier used for encrypting messages in the database activity
                                                    	// stream. The AWS KMS key identifier is the key ARN, key ID, alias ARN, or alias
                                                    	// name for the AWS KMS customer master key (CMK).
                                                    	ActivityStreamKmsKeyId *string
                                                    
                                                    	// The mode of the database activity stream. Database events such as a change or
                                                    	// access generate an activity stream event. The database session can handle these
                                                    	// events either synchronously or asynchronously.
                                                    	ActivityStreamMode ActivityStreamMode
                                                    
                                                    	// The status of the database activity stream.
                                                    	ActivityStreamStatus ActivityStreamStatus
                                                    
                                                    	// For all database engines except Amazon Aurora, AllocatedStorage specifies the
                                                    	// allocated storage size in gibibytes (GiB). For Aurora, AllocatedStorage always
                                                    	// returns 1, because Aurora DB cluster storage size isn't fixed, but instead
                                                    	// automatically adjusts as needed.
                                                    	AllocatedStorage *int32
                                                    
                                                    	// Provides a list of the AWS Identity and Access Management (IAM) roles that are
                                                    	// associated with the DB cluster. IAM roles that are associated with a DB cluster
                                                    	// grant permission for the DB cluster to access other AWS services on your behalf.
                                                    	AssociatedRoles []DBClusterRole
                                                    
                                                    	// Provides the list of Availability Zones (AZs) where instances in the DB cluster
                                                    	// can be created.
                                                    	AvailabilityZones []string
                                                    
                                                    	// The number of change records stored for Backtrack.
                                                    	BacktrackConsumedChangeRecords *int64
                                                    
                                                    	// The target backtrack window, in seconds. If this value is set to 0, backtracking
                                                    	// is disabled for the DB cluster. Otherwise, backtracking is enabled.
                                                    	BacktrackWindow *int64
                                                    
                                                    	// Specifies the number of days for which automatic DB snapshots are retained.
                                                    	BackupRetentionPeriod *int32
                                                    
                                                    	// The current capacity of an Aurora Serverless DB cluster. The capacity is 0
                                                    	// (zero) when the cluster is paused. For more information about Aurora Serverless,
                                                    	// see Using Amazon Aurora Serverless
                                                    	// (https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-serverless.html)
                                                    	// in the Amazon Aurora User Guide.
                                                    	Capacity *int32
                                                    
                                                    	// If present, specifies the name of the character set that this cluster is
                                                    	// associated with.
                                                    	CharacterSetName *string
                                                    
                                                    	// Identifies the clone group to which the DB cluster is associated.
                                                    	CloneGroupId *string
                                                    
                                                    	// Specifies the time when the DB cluster was created, in Universal Coordinated
                                                    	// Time (UTC).
                                                    	ClusterCreateTime *time.Time
                                                    
                                                    	// Specifies whether tags are copied from the DB cluster to snapshots of the DB
                                                    	// cluster.
                                                    	CopyTagsToSnapshot *bool
                                                    
                                                    	// Specifies whether the DB cluster is a clone of a DB cluster owned by a different
                                                    	// AWS account.
                                                    	CrossAccountClone *bool
                                                    
                                                    	// Identifies all custom endpoints associated with the cluster.
                                                    	CustomEndpoints []string
                                                    
                                                    	// The Amazon Resource Name (ARN) for the DB cluster.
                                                    	DBClusterArn *string
                                                    
                                                    	// Contains a user-supplied DB cluster identifier. This identifier is the unique
                                                    	// key that identifies a DB cluster.
                                                    	DBClusterIdentifier *string
                                                    
                                                    	// Provides the list of instances that make up the DB cluster.
                                                    	DBClusterMembers []DBClusterMember
                                                    
                                                    	// Provides the list of option group memberships for this DB cluster.
                                                    	DBClusterOptionGroupMemberships []DBClusterOptionGroupStatus
                                                    
                                                    	// Specifies the name of the DB cluster parameter group for the DB cluster.
                                                    	DBClusterParameterGroup *string
                                                    
                                                    	// Specifies information on the subnet group associated with the DB cluster,
                                                    	// including the name, description, and subnets in the subnet group.
                                                    	DBSubnetGroup *string
                                                    
                                                    	// Contains the name of the initial database of this DB cluster that was provided
                                                    	// at create time, if one was specified when the DB cluster was created. This same
                                                    	// name is returned for the life of the DB cluster.
                                                    	DatabaseName *string
                                                    
                                                    	// The AWS Region-unique, immutable identifier for the DB cluster. This identifier
                                                    	// is found in AWS CloudTrail log entries whenever the AWS KMS CMK for the DB
                                                    	// cluster is accessed.
                                                    	DbClusterResourceId *string
                                                    
                                                    	// Indicates if the DB cluster has deletion protection enabled. The database can't
                                                    	// be deleted when deletion protection is enabled.
                                                    	DeletionProtection *bool
                                                    
                                                    	// The Active Directory Domain membership records associated with the DB cluster.
                                                    	DomainMemberships []DomainMembership
                                                    
                                                    	// The earliest time to which a DB cluster can be backtracked.
                                                    	EarliestBacktrackTime *time.Time
                                                    
                                                    	// The earliest time to which a database can be restored with point-in-time
                                                    	// restore.
                                                    	EarliestRestorableTime *time.Time
                                                    
                                                    	// A list of log types that this DB cluster is configured to export to CloudWatch
                                                    	// Logs. Log types vary by DB engine. For information about the log types for each
                                                    	// DB engine, see Amazon RDS Database Log Files
                                                    	// (https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_LogAccess.html)
                                                    	// in the Amazon Aurora User Guide.
                                                    	EnabledCloudwatchLogsExports []string
                                                    
                                                    	// Specifies the connection endpoint for the primary instance of the DB cluster.
                                                    	Endpoint *string
                                                    
                                                    	// The name of the database engine to be used for this DB cluster.
                                                    	Engine *string
                                                    
                                                    	// The DB engine mode of the DB cluster, either provisioned, serverless,
                                                    	// parallelquery, global, or multimaster. For more information, see
                                                    	// CreateDBCluster
                                                    	// (https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBCluster.html).
                                                    	EngineMode *string
                                                    
                                                    	// Indicates the database engine version.
                                                    	EngineVersion *string
                                                    
                                                    	// Specifies whether you have requested to enable write forwarding for a secondary
                                                    	// cluster in an Aurora global database. Because write forwarding takes time to
                                                    	// enable, check the value of GlobalWriteForwardingStatus to confirm that the
                                                    	// request has completed before using the write forwarding feature for this
                                                    	// cluster.
                                                    	GlobalWriteForwardingRequested *bool
                                                    
                                                    	// Specifies whether a secondary cluster in an Aurora global database has write
                                                    	// forwarding enabled, not enabled, or is in the process of enabling it.
                                                    	GlobalWriteForwardingStatus WriteForwardingStatus
                                                    
                                                    	// Specifies the ID that Amazon Route 53 assigns when you create a hosted zone.
                                                    	HostedZoneId *string
                                                    
                                                    	// A value that indicates whether the HTTP endpoint for an Aurora Serverless DB
                                                    	// cluster is enabled. 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.
                                                    	HttpEndpointEnabled *bool
                                                    
                                                    	// A value that indicates whether the mapping of AWS Identity and Access Management
                                                    	// (IAM) accounts to database accounts is enabled.
                                                    	IAMDatabaseAuthenticationEnabled *bool
                                                    
                                                    	// If StorageEncrypted is enabled, the AWS KMS key identifier for the encrypted DB
                                                    	// cluster. The AWS KMS key identifier is the key ARN, key ID, alias ARN, or alias
                                                    	// name for the AWS KMS customer master key (CMK).
                                                    	KmsKeyId *string
                                                    
                                                    	// Specifies the latest time to which a database can be restored with point-in-time
                                                    	// restore.
                                                    	LatestRestorableTime *time.Time
                                                    
                                                    	// Contains the master username for the DB cluster.
                                                    	MasterUsername *string
                                                    
                                                    	// Specifies whether the DB cluster has instances in multiple Availability Zones.
                                                    	MultiAZ *bool
                                                    
                                                    	// Specifies that changes to the DB cluster are pending. This element is only
                                                    	// included when changes are pending. Specific changes are identified by
                                                    	// subelements.
                                                    	PendingModifiedValues *ClusterPendingModifiedValues
                                                    
                                                    	// Specifies the progress of the operation as a percentage.
                                                    	PercentProgress *string
                                                    
                                                    	// Specifies the port that the database engine is listening on.
                                                    	Port *int32
                                                    
                                                    	// Specifies the daily time range during which automated backups are created if
                                                    	// automated backups are enabled, as determined by the BackupRetentionPeriod.
                                                    	PreferredBackupWindow *string
                                                    
                                                    	// Specifies the weekly time range during which system maintenance can occur, in
                                                    	// Universal Coordinated Time (UTC).
                                                    	PreferredMaintenanceWindow *string
                                                    
                                                    	// Contains one or more identifiers of the read replicas associated with this DB
                                                    	// cluster.
                                                    	ReadReplicaIdentifiers []string
                                                    
                                                    	// The reader endpoint for the DB cluster. The reader endpoint for a DB cluster
                                                    	// load-balances connections across the Aurora Replicas that are available in a DB
                                                    	// cluster. As clients request new connections to the reader endpoint, Aurora
                                                    	// distributes the connection requests among the Aurora Replicas in the DB cluster.
                                                    	// This functionality can help balance your read workload across multiple Aurora
                                                    	// Replicas in your DB cluster. If a failover occurs, and the Aurora Replica that
                                                    	// you are connected to is promoted to be the primary instance, your connection is
                                                    	// dropped. To continue sending your read workload to other Aurora Replicas in the
                                                    	// cluster, you can then reconnect to the reader endpoint.
                                                    	ReaderEndpoint *string
                                                    
                                                    	// Contains the identifier of the source DB cluster if this DB cluster is a read
                                                    	// replica.
                                                    	ReplicationSourceIdentifier *string
                                                    
                                                    	// Shows the scaling configuration for an Aurora DB cluster in serverless DB engine
                                                    	// mode. For more information, see Using Amazon Aurora Serverless
                                                    	// (https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-serverless.html)
                                                    	// in the Amazon Aurora User Guide.
                                                    	ScalingConfigurationInfo *ScalingConfigurationInfo
                                                    
                                                    	// Specifies the current state of this DB cluster.
                                                    	Status *string
                                                    
                                                    	// Specifies whether the DB cluster is encrypted.
                                                    	StorageEncrypted 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.
                                                    	TagList []Tag
                                                    
                                                    	// Provides a list of VPC security groups that the DB cluster belongs to.
                                                    	VpcSecurityGroups []VpcSecurityGroupMembership
                                                    }

                                                      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.

                                                      type DBClusterAlreadyExistsFault

                                                      type DBClusterAlreadyExistsFault struct {
                                                      	Message *string
                                                      }

                                                        The user already has a DB cluster with the given identifier.

                                                        func (*DBClusterAlreadyExistsFault) Error

                                                        func (*DBClusterAlreadyExistsFault) ErrorCode

                                                        func (e *DBClusterAlreadyExistsFault) ErrorCode() string

                                                        func (*DBClusterAlreadyExistsFault) ErrorFault

                                                        func (*DBClusterAlreadyExistsFault) ErrorMessage

                                                        func (e *DBClusterAlreadyExistsFault) ErrorMessage() string

                                                        type DBClusterBacktrack

                                                        type DBClusterBacktrack struct {
                                                        
                                                        	// Contains the backtrack identifier.
                                                        	BacktrackIdentifier *string
                                                        
                                                        	// The timestamp of the time at which the backtrack was requested.
                                                        	BacktrackRequestCreationTime *time.Time
                                                        
                                                        	// The timestamp of the time to which the DB cluster was backtracked.
                                                        	BacktrackTo *time.Time
                                                        
                                                        	// The timestamp of the time from which the DB cluster was backtracked.
                                                        	BacktrackedFrom *time.Time
                                                        
                                                        	// Contains a user-supplied DB cluster identifier. This identifier is the unique
                                                        	// key that identifies a DB cluster.
                                                        	DBClusterIdentifier *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
                                                        }

                                                          This data type is used as a response element in the DescribeDBClusterBacktracks action.

                                                          type DBClusterBacktrackNotFoundFault

                                                          type DBClusterBacktrackNotFoundFault struct {
                                                          	Message *string
                                                          }

                                                            BacktrackIdentifier doesn't refer to an existing backtrack.

                                                            func (*DBClusterBacktrackNotFoundFault) Error

                                                            func (*DBClusterBacktrackNotFoundFault) ErrorCode

                                                            func (e *DBClusterBacktrackNotFoundFault) ErrorCode() string

                                                            func (*DBClusterBacktrackNotFoundFault) ErrorFault

                                                            func (*DBClusterBacktrackNotFoundFault) ErrorMessage

                                                            func (e *DBClusterBacktrackNotFoundFault) ErrorMessage() string

                                                            type DBClusterEndpoint

                                                            type DBClusterEndpoint struct {
                                                            
                                                            	// The type associated with a custom endpoint. One of: READER, WRITER, ANY.
                                                            	CustomEndpointType *string
                                                            
                                                            	// The Amazon Resource Name (ARN) for the endpoint.
                                                            	DBClusterEndpointArn *string
                                                            
                                                            	// The identifier associated with the endpoint. This parameter is stored as a
                                                            	// lowercase string.
                                                            	DBClusterEndpointIdentifier *string
                                                            
                                                            	// A unique system-generated identifier for an endpoint. It remains the same for
                                                            	// the whole life of the endpoint.
                                                            	DBClusterEndpointResourceIdentifier *string
                                                            
                                                            	// The DB cluster identifier of the DB cluster associated with the endpoint. This
                                                            	// parameter is stored as a lowercase string.
                                                            	DBClusterIdentifier *string
                                                            
                                                            	// The DNS address of the endpoint.
                                                            	Endpoint *string
                                                            
                                                            	// The type of the endpoint. One of: READER, WRITER, CUSTOM.
                                                            	EndpointType *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
                                                            
                                                            	// List of DB instance identifiers that are part of the custom endpoint group.
                                                            	StaticMembers []string
                                                            
                                                            	// The current status of the endpoint. One of: creating, available, deleting,
                                                            	// inactive, modifying. The inactive state applies to an endpoint that can't be
                                                            	// used for a certain kind of cluster, such as a writer endpoint for a read-only
                                                            	// secondary cluster in a global database.
                                                            	Status *string
                                                            }

                                                              This data type represents the information you need to connect to an Amazon Aurora DB cluster. This data type is used as a response element in the following actions:

                                                              * CreateDBClusterEndpoint

                                                              * DescribeDBClusterEndpoints

                                                              * ModifyDBClusterEndpoint

                                                              * DeleteDBClusterEndpoint

                                                              For the data structure that represents Amazon RDS DB instance endpoints, see Endpoint.

                                                              type DBClusterEndpointAlreadyExistsFault

                                                              type DBClusterEndpointAlreadyExistsFault struct {
                                                              	Message *string
                                                              }

                                                                The specified custom endpoint can't be created because it already exists.

                                                                func (*DBClusterEndpointAlreadyExistsFault) Error

                                                                func (*DBClusterEndpointAlreadyExistsFault) ErrorCode

                                                                func (*DBClusterEndpointAlreadyExistsFault) ErrorFault

                                                                func (*DBClusterEndpointAlreadyExistsFault) ErrorMessage

                                                                func (e *DBClusterEndpointAlreadyExistsFault) ErrorMessage() string

                                                                type DBClusterEndpointNotFoundFault

                                                                type DBClusterEndpointNotFoundFault struct {
                                                                	Message *string
                                                                }

                                                                  The specified custom endpoint doesn't exist.

                                                                  func (*DBClusterEndpointNotFoundFault) Error

                                                                  func (*DBClusterEndpointNotFoundFault) ErrorCode

                                                                  func (e *DBClusterEndpointNotFoundFault) ErrorCode() string

                                                                  func (*DBClusterEndpointNotFoundFault) ErrorFault

                                                                  func (*DBClusterEndpointNotFoundFault) ErrorMessage

                                                                  func (e *DBClusterEndpointNotFoundFault) ErrorMessage() string

                                                                  type DBClusterEndpointQuotaExceededFault

                                                                  type DBClusterEndpointQuotaExceededFault struct {
                                                                  	Message *string
                                                                  }

                                                                    The cluster already has the maximum number of custom endpoints.

                                                                    func (*DBClusterEndpointQuotaExceededFault) Error

                                                                    func (*DBClusterEndpointQuotaExceededFault) ErrorCode

                                                                    func (*DBClusterEndpointQuotaExceededFault) ErrorFault

                                                                    func (*DBClusterEndpointQuotaExceededFault) ErrorMessage

                                                                    func (e *DBClusterEndpointQuotaExceededFault) ErrorMessage() string

                                                                    type DBClusterMember

                                                                    type DBClusterMember struct {
                                                                    
                                                                    	// Specifies the status of the DB cluster parameter group for this member of the DB
                                                                    	// cluster.
                                                                    	DBClusterParameterGroupStatus *string
                                                                    
                                                                    	// Specifies the instance identifier for this member of the DB cluster.
                                                                    	DBInstanceIdentifier *string
                                                                    
                                                                    	// Value that is true if the cluster member is the primary instance for the DB
                                                                    	// cluster and false otherwise.
                                                                    	IsClusterWriter 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.
                                                                    	PromotionTier *int32
                                                                    }

                                                                      Contains information about an instance that is part of a DB cluster.

                                                                      type DBClusterNotFoundFault

                                                                      type DBClusterNotFoundFault struct {
                                                                      	Message *string
                                                                      }

                                                                        DBClusterIdentifier doesn't refer to an existing DB cluster.

                                                                        func (*DBClusterNotFoundFault) Error

                                                                        func (e *DBClusterNotFoundFault) Error() string

                                                                        func (*DBClusterNotFoundFault) ErrorCode

                                                                        func (e *DBClusterNotFoundFault) ErrorCode() string

                                                                        func (*DBClusterNotFoundFault) ErrorFault

                                                                        func (e *DBClusterNotFoundFault) ErrorFault() smithy.ErrorFault

                                                                        func (*DBClusterNotFoundFault) ErrorMessage

                                                                        func (e *DBClusterNotFoundFault) ErrorMessage() string

                                                                        type DBClusterOptionGroupStatus

                                                                        type DBClusterOptionGroupStatus struct {
                                                                        
                                                                        	// Specifies the name of the DB cluster option group.
                                                                        	DBClusterOptionGroupName *string
                                                                        
                                                                        	// Specifies the status of the DB cluster option group.
                                                                        	Status *string
                                                                        }

                                                                          Contains status information for a DB cluster option group.

                                                                          type DBClusterParameterGroup

                                                                          type DBClusterParameterGroup struct {
                                                                          
                                                                          	// The Amazon Resource Name (ARN) for the DB cluster parameter group.
                                                                          	DBClusterParameterGroupArn *string
                                                                          
                                                                          	// The name of the DB cluster parameter group.
                                                                          	DBClusterParameterGroupName *string
                                                                          
                                                                          	// The name of the DB parameter group family that this DB cluster parameter group
                                                                          	// is compatible with.
                                                                          	DBParameterGroupFamily *string
                                                                          
                                                                          	// Provides the customer-specified description for this DB cluster parameter group.
                                                                          	Description *string
                                                                          }

                                                                            Contains the details of an Amazon RDS DB cluster parameter group. This data type is used as a response element in the DescribeDBClusterParameterGroups action.

                                                                            type DBClusterParameterGroupNotFoundFault

                                                                            type DBClusterParameterGroupNotFoundFault struct {
                                                                            	Message *string
                                                                            }

                                                                              DBClusterParameterGroupName doesn't refer to an existing DB cluster parameter group.

                                                                              func (*DBClusterParameterGroupNotFoundFault) Error

                                                                              func (*DBClusterParameterGroupNotFoundFault) ErrorCode

                                                                              func (*DBClusterParameterGroupNotFoundFault) ErrorFault

                                                                              func (*DBClusterParameterGroupNotFoundFault) ErrorMessage

                                                                              func (e *DBClusterParameterGroupNotFoundFault) ErrorMessage() string

                                                                              type DBClusterQuotaExceededFault

                                                                              type DBClusterQuotaExceededFault struct {
                                                                              	Message *string
                                                                              }

                                                                                The user attempted to create a new DB cluster and the user has already reached the maximum allowed DB cluster quota.

                                                                                func (*DBClusterQuotaExceededFault) Error

                                                                                func (*DBClusterQuotaExceededFault) ErrorCode

                                                                                func (e *DBClusterQuotaExceededFault) ErrorCode() string

                                                                                func (*DBClusterQuotaExceededFault) ErrorFault

                                                                                func (*DBClusterQuotaExceededFault) ErrorMessage

                                                                                func (e *DBClusterQuotaExceededFault) ErrorMessage() string

                                                                                type DBClusterRole

                                                                                type DBClusterRole struct {
                                                                                
                                                                                	// The name of the feature associated with the AWS Identity and Access Management
                                                                                	// (IAM) role. For the list of supported feature names, see DBEngineVersion.
                                                                                	FeatureName *string
                                                                                
                                                                                	// The Amazon Resource Name (ARN) of the IAM role that is associated with the DB
                                                                                	// cluster.
                                                                                	RoleArn *string
                                                                                
                                                                                	// Describes the state of association between the IAM role and the DB cluster. The
                                                                                	// Status property returns one of the following values:
                                                                                	//
                                                                                	// * ACTIVE - the IAM role
                                                                                	// ARN is associated with the DB cluster and can be used to access other AWS
                                                                                	// services on your behalf.
                                                                                	//
                                                                                	// * PENDING - the IAM role ARN is being associated with
                                                                                	// the DB cluster.
                                                                                	//
                                                                                	// * INVALID - the IAM role ARN is associated with the DB cluster,
                                                                                	// but the DB cluster is unable to assume the IAM role in order to access other AWS
                                                                                	// services on your behalf.
                                                                                	Status *string
                                                                                }

                                                                                  Describes an AWS Identity and Access Management (IAM) role that is associated with a DB cluster.

                                                                                  type DBClusterRoleAlreadyExistsFault

                                                                                  type DBClusterRoleAlreadyExistsFault struct {
                                                                                  	Message *string
                                                                                  }

                                                                                    The specified IAM role Amazon Resource Name (ARN) is already associated with the specified DB cluster.

                                                                                    func (*DBClusterRoleAlreadyExistsFault) Error

                                                                                    func (*DBClusterRoleAlreadyExistsFault) ErrorCode

                                                                                    func (e *DBClusterRoleAlreadyExistsFault) ErrorCode() string

                                                                                    func (*DBClusterRoleAlreadyExistsFault) ErrorFault

                                                                                    func (*DBClusterRoleAlreadyExistsFault) ErrorMessage

                                                                                    func (e *DBClusterRoleAlreadyExistsFault) ErrorMessage() string

                                                                                    type DBClusterRoleNotFoundFault

                                                                                    type DBClusterRoleNotFoundFault struct {
                                                                                    	Message *string
                                                                                    }

                                                                                      The specified IAM role Amazon Resource Name (ARN) isn't associated with the specified DB cluster.

                                                                                      func (*DBClusterRoleNotFoundFault) Error

                                                                                      func (*DBClusterRoleNotFoundFault) ErrorCode

                                                                                      func (e *DBClusterRoleNotFoundFault) ErrorCode() string

                                                                                      func (*DBClusterRoleNotFoundFault) ErrorFault

                                                                                      func (*DBClusterRoleNotFoundFault) ErrorMessage

                                                                                      func (e *DBClusterRoleNotFoundFault) ErrorMessage() string

                                                                                      type DBClusterRoleQuotaExceededFault

                                                                                      type DBClusterRoleQuotaExceededFault struct {
                                                                                      	Message *string
                                                                                      }

                                                                                        You have exceeded the maximum number of IAM roles that can be associated with the specified DB cluster.

                                                                                        func (*DBClusterRoleQuotaExceededFault) Error

                                                                                        func (*DBClusterRoleQuotaExceededFault) ErrorCode

                                                                                        func (e *DBClusterRoleQuotaExceededFault) ErrorCode() string

                                                                                        func (*DBClusterRoleQuotaExceededFault) ErrorFault

                                                                                        func (*DBClusterRoleQuotaExceededFault) ErrorMessage

                                                                                        func (e *DBClusterRoleQuotaExceededFault) ErrorMessage() string

                                                                                        type DBClusterSnapshot

                                                                                        type DBClusterSnapshot struct {
                                                                                        
                                                                                        	// Specifies the allocated storage size in gibibytes (GiB).
                                                                                        	AllocatedStorage int32
                                                                                        
                                                                                        	// Provides the list of Availability Zones (AZs) where instances in the DB cluster
                                                                                        	// snapshot can be restored.
                                                                                        	AvailabilityZones []string
                                                                                        
                                                                                        	// Specifies the time when the DB cluster was created, in Universal Coordinated
                                                                                        	// Time (UTC).
                                                                                        	ClusterCreateTime *time.Time
                                                                                        
                                                                                        	// Specifies the DB cluster identifier of the DB cluster that this DB cluster
                                                                                        	// snapshot was created from.
                                                                                        	DBClusterIdentifier *string
                                                                                        
                                                                                        	// The Amazon Resource Name (ARN) for the DB cluster snapshot.
                                                                                        	DBClusterSnapshotArn *string
                                                                                        
                                                                                        	// Specifies the identifier for the DB cluster snapshot.
                                                                                        	DBClusterSnapshotIdentifier *string
                                                                                        
                                                                                        	// Specifies the name of the database engine.
                                                                                        	Engine *string
                                                                                        
                                                                                        	// Provides the version of the database engine for this DB cluster snapshot.
                                                                                        	EngineVersion *string
                                                                                        
                                                                                        	// True if mapping of AWS Identity and Access Management (IAM) accounts to database
                                                                                        	// accounts is enabled, and otherwise false.
                                                                                        	IAMDatabaseAuthenticationEnabled bool
                                                                                        
                                                                                        	// If StorageEncrypted is true, the AWS KMS key identifier for the encrypted DB
                                                                                        	// cluster snapshot. The AWS KMS key identifier is the key ARN, key ID, alias ARN,
                                                                                        	// or alias name for the AWS KMS customer master key (CMK).
                                                                                        	KmsKeyId *string
                                                                                        
                                                                                        	// Provides the license model information for this DB cluster snapshot.
                                                                                        	LicenseModel *string
                                                                                        
                                                                                        	// Provides the master username for the DB cluster snapshot.
                                                                                        	MasterUsername *string
                                                                                        
                                                                                        	// Specifies the percentage of the estimated data that has been transferred.
                                                                                        	PercentProgress int32
                                                                                        
                                                                                        	// Specifies the port that the DB cluster was listening on at the time of the
                                                                                        	// snapshot.
                                                                                        	Port int32
                                                                                        
                                                                                        	// Provides the time when the snapshot was taken, in Universal Coordinated Time
                                                                                        	// (UTC).
                                                                                        	SnapshotCreateTime *time.Time
                                                                                        
                                                                                        	// Provides the type of the DB cluster snapshot.
                                                                                        	SnapshotType *string
                                                                                        
                                                                                        	// If the DB cluster snapshot was copied from a source DB cluster snapshot, the
                                                                                        	// Amazon Resource Name (ARN) for the source DB cluster snapshot, otherwise, a null
                                                                                        	// value.
                                                                                        	SourceDBClusterSnapshotArn *string
                                                                                        
                                                                                        	// Specifies the status of this DB cluster snapshot.
                                                                                        	Status *string
                                                                                        
                                                                                        	// Specifies whether the DB cluster snapshot is encrypted.
                                                                                        	StorageEncrypted 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.
                                                                                        	TagList []Tag
                                                                                        
                                                                                        	// Provides the VPC ID associated with the DB cluster snapshot.
                                                                                        	VpcId *string
                                                                                        }

                                                                                          Contains the details for an Amazon RDS DB cluster snapshot This data type is used as a response element in the DescribeDBClusterSnapshots action.

                                                                                          type DBClusterSnapshotAlreadyExistsFault

                                                                                          type DBClusterSnapshotAlreadyExistsFault struct {
                                                                                          	Message *string
                                                                                          }

                                                                                            The user already has a DB cluster snapshot with the given identifier.

                                                                                            func (*DBClusterSnapshotAlreadyExistsFault) Error

                                                                                            func (*DBClusterSnapshotAlreadyExistsFault) ErrorCode

                                                                                            func (*DBClusterSnapshotAlreadyExistsFault) ErrorFault

                                                                                            func (*DBClusterSnapshotAlreadyExistsFault) ErrorMessage

                                                                                            func (e *DBClusterSnapshotAlreadyExistsFault) ErrorMessage() string

                                                                                            type DBClusterSnapshotAttribute

                                                                                            type DBClusterSnapshotAttribute struct {
                                                                                            
                                                                                            	// The name of the manual DB cluster snapshot attribute. The attribute named
                                                                                            	// restore refers to the list of AWS accounts that have permission to copy or
                                                                                            	// restore the manual DB cluster snapshot. For more information, see the
                                                                                            	// ModifyDBClusterSnapshotAttribute API action.
                                                                                            	AttributeName *string
                                                                                            
                                                                                            	// The value(s) for the manual DB cluster snapshot attribute. If the AttributeName
                                                                                            	// field is set to restore, then this element returns a list of IDs of the AWS
                                                                                            	// accounts that are authorized to copy or restore the manual DB cluster snapshot.
                                                                                            	// If a value of all is in the list, then the manual DB cluster snapshot is public
                                                                                            	// and available for any AWS account to copy or restore.
                                                                                            	AttributeValues []string
                                                                                            }

                                                                                              Contains the name and values of a manual DB cluster snapshot attribute. Manual DB cluster snapshot attributes are used to authorize other AWS accounts to restore a manual DB cluster snapshot. For more information, see the ModifyDBClusterSnapshotAttribute API action.

                                                                                              type DBClusterSnapshotAttributesResult

                                                                                              type DBClusterSnapshotAttributesResult struct {
                                                                                              
                                                                                              	// The list of attributes and values for the manual DB cluster snapshot.
                                                                                              	DBClusterSnapshotAttributes []DBClusterSnapshotAttribute
                                                                                              
                                                                                              	// The identifier of the manual DB cluster snapshot that the attributes apply to.
                                                                                              	DBClusterSnapshotIdentifier *string
                                                                                              }

                                                                                                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.

                                                                                                type DBClusterSnapshotNotFoundFault

                                                                                                type DBClusterSnapshotNotFoundFault struct {
                                                                                                	Message *string
                                                                                                }

                                                                                                  DBClusterSnapshotIdentifier doesn't refer to an existing DB cluster snapshot.

                                                                                                  func (*DBClusterSnapshotNotFoundFault) Error

                                                                                                  func (*DBClusterSnapshotNotFoundFault) ErrorCode

                                                                                                  func (e *DBClusterSnapshotNotFoundFault) ErrorCode() string

                                                                                                  func (*DBClusterSnapshotNotFoundFault) ErrorFault

                                                                                                  func (*DBClusterSnapshotNotFoundFault) ErrorMessage

                                                                                                  func (e *DBClusterSnapshotNotFoundFault) ErrorMessage() string

                                                                                                  type DBEngineVersion

                                                                                                  type DBEngineVersion struct {
                                                                                                  
                                                                                                  	// The description of the database engine.
                                                                                                  	DBEngineDescription *string
                                                                                                  
                                                                                                  	// The description of the database engine version.
                                                                                                  	DBEngineVersionDescription *string
                                                                                                  
                                                                                                  	// The name of the DB parameter group family for the database engine.
                                                                                                  	DBParameterGroupFamily *string
                                                                                                  
                                                                                                  	// The default character set for new instances of this engine version, if the
                                                                                                  	// CharacterSetName parameter of the CreateDBInstance API isn't specified.
                                                                                                  	DefaultCharacterSet *CharacterSet
                                                                                                  
                                                                                                  	// The name of the database engine.
                                                                                                  	Engine *string
                                                                                                  
                                                                                                  	// The version number of the database engine.
                                                                                                  	EngineVersion *string
                                                                                                  
                                                                                                  	// The types of logs that the database engine has available for export to
                                                                                                  	// CloudWatch Logs.
                                                                                                  	ExportableLogTypes []string
                                                                                                  
                                                                                                  	// The status of the DB engine version, either available or deprecated.
                                                                                                  	Status *string
                                                                                                  
                                                                                                  	// A list of the character sets supported by this engine for the CharacterSetName
                                                                                                  	// parameter of the CreateDBInstance operation.
                                                                                                  	SupportedCharacterSets []CharacterSet
                                                                                                  
                                                                                                  	// A list of the supported DB engine modes.
                                                                                                  	SupportedEngineModes []string
                                                                                                  
                                                                                                  	// A list of features supported by the DB engine. Supported feature names include
                                                                                                  	// the following.
                                                                                                  	//
                                                                                                  	// * s3Import
                                                                                                  	SupportedFeatureNames []string
                                                                                                  
                                                                                                  	// A list of the character sets supported by the Oracle DB engine for the
                                                                                                  	// NcharCharacterSetName parameter of the CreateDBInstance operation.
                                                                                                  	SupportedNcharCharacterSets []CharacterSet
                                                                                                  
                                                                                                  	// A list of the time zones supported by this engine for the Timezone parameter of
                                                                                                  	// the CreateDBInstance action.
                                                                                                  	SupportedTimezones []Timezone
                                                                                                  
                                                                                                  	// A value that indicates whether you can use Aurora global databases with a
                                                                                                  	// specific DB engine version.
                                                                                                  	SupportsGlobalDatabases bool
                                                                                                  
                                                                                                  	// A value that indicates whether the engine version supports exporting the log
                                                                                                  	// types specified by ExportableLogTypes to CloudWatch Logs.
                                                                                                  	SupportsLogExportsToCloudwatchLogs bool
                                                                                                  
                                                                                                  	// A value that indicates whether you can use Aurora parallel query with a specific
                                                                                                  	// DB engine version.
                                                                                                  	SupportsParallelQuery bool
                                                                                                  
                                                                                                  	// Indicates whether the database engine version supports read replicas.
                                                                                                  	SupportsReadReplica bool
                                                                                                  
                                                                                                  	// A list of engine versions that this database engine version can be upgraded to.
                                                                                                  	ValidUpgradeTarget []UpgradeTarget
                                                                                                  }

                                                                                                    This data type is used as a response element in the action DescribeDBEngineVersions.

                                                                                                    type DBInstance

                                                                                                    type DBInstance struct {
                                                                                                    
                                                                                                    	// Specifies the allocated storage size specified in gibibytes.
                                                                                                    	AllocatedStorage int32
                                                                                                    
                                                                                                    	// The AWS Identity and Access Management (IAM) roles associated with the DB
                                                                                                    	// instance.
                                                                                                    	AssociatedRoles []DBInstanceRole
                                                                                                    
                                                                                                    	// Indicates that minor version patches are applied automatically.
                                                                                                    	AutoMinorVersionUpgrade bool
                                                                                                    
                                                                                                    	// Specifies the name of the Availability Zone the DB instance is located in.
                                                                                                    	AvailabilityZone *string
                                                                                                    
                                                                                                    	// Specifies the number of days for which automatic DB snapshots are retained.
                                                                                                    	BackupRetentionPeriod int32
                                                                                                    
                                                                                                    	// The identifier of the CA certificate for this DB instance.
                                                                                                    	CACertificateIdentifier *string
                                                                                                    
                                                                                                    	// If present, specifies the name of the character set that this instance is
                                                                                                    	// associated with.
                                                                                                    	CharacterSetName *string
                                                                                                    
                                                                                                    	// Specifies whether tags are copied from the DB instance to snapshots of the DB
                                                                                                    	// instance. 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. For more information, see DBCluster.
                                                                                                    	CopyTagsToSnapshot bool
                                                                                                    
                                                                                                    	// Specifies whether a customer-owned IP address (CoIP) is enabled for an RDS on
                                                                                                    	// Outposts DB instance. A CoIP provides local or external connectivity to
                                                                                                    	// resources in your Outpost subnets through your on-premises network. For some use
                                                                                                    	// cases, a CoIP can provide lower latency for connections to the DB instance from
                                                                                                    	// outside of its virtual private cloud (VPC) on your local network. For more
                                                                                                    	// information about RDS on Outposts, see Working with Amazon RDS on AWS Outposts
                                                                                                    	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-on-outposts.html) in
                                                                                                    	// the Amazon RDS User Guide. For more information about CoIPs, see Customer-owned
                                                                                                    	// IP addresses
                                                                                                    	// (https://docs.aws.amazon.com/outposts/latest/userguide/outposts-networking-components.html#ip-addressing)
                                                                                                    	// in the AWS Outposts User Guide.
                                                                                                    	CustomerOwnedIpEnabled *bool
                                                                                                    
                                                                                                    	// If the DB instance is a member of a DB cluster, contains the name of the DB
                                                                                                    	// cluster that the DB instance is a member of.
                                                                                                    	DBClusterIdentifier *string
                                                                                                    
                                                                                                    	// The Amazon Resource Name (ARN) for the DB instance.
                                                                                                    	DBInstanceArn *string
                                                                                                    
                                                                                                    	// The list of replicated automated backups associated with the DB instance.
                                                                                                    	DBInstanceAutomatedBackupsReplications []DBInstanceAutomatedBackupsReplication
                                                                                                    
                                                                                                    	// Contains the name of the compute and memory capacity class of the DB instance.
                                                                                                    	DBInstanceClass *string
                                                                                                    
                                                                                                    	// Contains a user-supplied database identifier. This identifier is the unique key
                                                                                                    	// that identifies a DB instance.
                                                                                                    	DBInstanceIdentifier *string
                                                                                                    
                                                                                                    	// Specifies the current state of this database. For information about DB instance
                                                                                                    	// statuses, see DB Instance Status
                                                                                                    	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.DBInstance.Status.html)
                                                                                                    	// in the Amazon RDS User Guide.
                                                                                                    	DBInstanceStatus *string
                                                                                                    
                                                                                                    	// The meaning of this parameter differs according to the database engine you use.
                                                                                                    	// MySQL, MariaDB, SQL Server, PostgreSQL Contains the name of the initial database
                                                                                                    	// of this instance that was provided at create time, if one was specified when the
                                                                                                    	// DB instance was created. This same name is returned for the life of the DB
                                                                                                    	// instance. Type: String Oracle Contains the Oracle System ID (SID) of the created
                                                                                                    	// DB instance. Not shown when the returned parameters do not apply to an Oracle DB
                                                                                                    	// instance.
                                                                                                    	DBName *string
                                                                                                    
                                                                                                    	// Provides the list of DB parameter groups applied to this DB instance.
                                                                                                    	DBParameterGroups []DBParameterGroupStatus
                                                                                                    
                                                                                                    	// A list of DB security group elements containing DBSecurityGroup.Name and
                                                                                                    	// DBSecurityGroup.Status subelements.
                                                                                                    	DBSecurityGroups []DBSecurityGroupMembership
                                                                                                    
                                                                                                    	// Specifies information on the subnet group associated with the DB instance,
                                                                                                    	// including the name, description, and subnets in the subnet group.
                                                                                                    	DBSubnetGroup *DBSubnetGroup
                                                                                                    
                                                                                                    	// Specifies the port that the DB instance listens on. If the DB instance is part
                                                                                                    	// of a DB cluster, this can be a different port than the DB cluster port.
                                                                                                    	DbInstancePort int32
                                                                                                    
                                                                                                    	// The AWS Region-unique, immutable identifier for the DB instance. This identifier
                                                                                                    	// is found in AWS CloudTrail log entries whenever the AWS KMS customer master key
                                                                                                    	// (CMK) for the DB instance is accessed.
                                                                                                    	DbiResourceId *string
                                                                                                    
                                                                                                    	// Indicates if the DB instance has deletion protection enabled. The database can't
                                                                                                    	// be deleted when deletion protection is enabled. For more information, see
                                                                                                    	// Deleting a DB Instance
                                                                                                    	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_DeleteInstance.html).
                                                                                                    	DeletionProtection bool
                                                                                                    
                                                                                                    	// The Active Directory Domain membership records associated with the DB instance.
                                                                                                    	DomainMemberships []DomainMembership
                                                                                                    
                                                                                                    	// A list of log types that this DB instance is configured to export to CloudWatch
                                                                                                    	// Logs. Log types vary by DB engine. For information about the log types for each
                                                                                                    	// DB engine, see Amazon RDS Database Log Files
                                                                                                    	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_LogAccess.html) in
                                                                                                    	// the Amazon RDS User Guide.
                                                                                                    	EnabledCloudwatchLogsExports []string
                                                                                                    
                                                                                                    	// Specifies the connection endpoint.
                                                                                                    	Endpoint *Endpoint
                                                                                                    
                                                                                                    	// The name of the database engine to be used for this DB instance.
                                                                                                    	Engine *string
                                                                                                    
                                                                                                    	// Indicates the database engine version.
                                                                                                    	EngineVersion *string
                                                                                                    
                                                                                                    	// The Amazon Resource Name (ARN) of the Amazon CloudWatch Logs log stream that
                                                                                                    	// receives the Enhanced Monitoring metrics data for the DB instance.
                                                                                                    	EnhancedMonitoringResourceArn *string
                                                                                                    
                                                                                                    	// True if mapping of AWS Identity and Access Management (IAM) accounts to database
                                                                                                    	// accounts is enabled, and otherwise false. IAM database authentication can be
                                                                                                    	// enabled for the following database engines
                                                                                                    	//
                                                                                                    	// * For MySQL 5.6, minor version
                                                                                                    	// 5.6.34 or higher
                                                                                                    	//
                                                                                                    	// * For MySQL 5.7, minor version 5.7.16 or higher
                                                                                                    	//
                                                                                                    	// * Aurora 5.6
                                                                                                    	// or higher. To enable IAM database authentication for Aurora, see DBCluster Type.
                                                                                                    	IAMDatabaseAuthenticationEnabled bool
                                                                                                    
                                                                                                    	// Provides the date and time the DB instance was created.
                                                                                                    	InstanceCreateTime *time.Time
                                                                                                    
                                                                                                    	// Specifies the Provisioned IOPS (I/O operations per second) value.
                                                                                                    	Iops *int32
                                                                                                    
                                                                                                    	// If StorageEncrypted is true, the AWS KMS key identifier for the encrypted DB
                                                                                                    	// instance. The AWS KMS key identifier is the key ARN, key ID, alias ARN, or alias
                                                                                                    	// name for the AWS KMS customer master key (CMK).
                                                                                                    	KmsKeyId *string
                                                                                                    
                                                                                                    	// Specifies the latest time to which a database can be restored with point-in-time
                                                                                                    	// restore.
                                                                                                    	LatestRestorableTime *time.Time
                                                                                                    
                                                                                                    	// License model information for this DB instance.
                                                                                                    	LicenseModel *string
                                                                                                    
                                                                                                    	// Specifies the listener connection endpoint for SQL Server Always On.
                                                                                                    	ListenerEndpoint *Endpoint
                                                                                                    
                                                                                                    	// Contains the master username for the DB instance.
                                                                                                    	MasterUsername *string
                                                                                                    
                                                                                                    	// The upper limit to which Amazon RDS can automatically scale the storage of the
                                                                                                    	// DB instance.
                                                                                                    	MaxAllocatedStorage *int32
                                                                                                    
                                                                                                    	// The interval, in seconds, between points when Enhanced Monitoring metrics are
                                                                                                    	// collected for the DB instance.
                                                                                                    	MonitoringInterval *int32
                                                                                                    
                                                                                                    	// The ARN for the IAM role that permits RDS to send Enhanced Monitoring metrics to
                                                                                                    	// Amazon CloudWatch Logs.
                                                                                                    	MonitoringRoleArn *string
                                                                                                    
                                                                                                    	// Specifies if the DB instance is a Multi-AZ deployment.
                                                                                                    	MultiAZ bool
                                                                                                    
                                                                                                    	// The name of the NCHAR character set for the Oracle DB instance. This character
                                                                                                    	// set specifies the Unicode encoding for data stored in table columns of type
                                                                                                    	// NCHAR, NCLOB, or NVARCHAR2.
                                                                                                    	NcharCharacterSetName *string
                                                                                                    
                                                                                                    	// Provides the list of option group memberships for this DB instance.
                                                                                                    	OptionGroupMemberships []OptionGroupMembership
                                                                                                    
                                                                                                    	// Specifies that changes to the DB instance are pending. This element is only
                                                                                                    	// included when changes are pending. Specific changes are identified by
                                                                                                    	// subelements.
                                                                                                    	PendingModifiedValues *PendingModifiedValues
                                                                                                    
                                                                                                    	// True if Performance Insights is enabled for the DB instance, and otherwise
                                                                                                    	// false.
                                                                                                    	PerformanceInsightsEnabled *bool
                                                                                                    
                                                                                                    	// The AWS KMS key identifier for encryption of Performance Insights data. The AWS
                                                                                                    	// KMS key identifier is the key ARN, key ID, alias ARN, or alias name for the AWS
                                                                                                    	// KMS customer master key (CMK).
                                                                                                    	PerformanceInsightsKMSKeyId *string
                                                                                                    
                                                                                                    	// The amount of time, in days, to retain Performance Insights data. Valid values
                                                                                                    	// are 7 or 731 (2 years).
                                                                                                    	PerformanceInsightsRetentionPeriod *int32
                                                                                                    
                                                                                                    	// Specifies the daily time range during which automated backups are created if
                                                                                                    	// automated backups are enabled, as determined by the BackupRetentionPeriod.
                                                                                                    	PreferredBackupWindow *string
                                                                                                    
                                                                                                    	// Specifies the weekly time range during which system maintenance can occur, in
                                                                                                    	// Universal Coordinated Time (UTC).
                                                                                                    	PreferredMaintenanceWindow *string
                                                                                                    
                                                                                                    	// The number of CPU cores and the number of threads per core for the DB instance
                                                                                                    	// class of the DB instance.
                                                                                                    	ProcessorFeatures []ProcessorFeature
                                                                                                    
                                                                                                    	// 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.
                                                                                                    	PromotionTier *int32
                                                                                                    
                                                                                                    	// Specifies the accessibility options for the DB instance. 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
                                                                                                    
                                                                                                    	// Contains one or more identifiers of Aurora DB clusters to which the RDS DB
                                                                                                    	// instance is replicated as a read replica. For example, when you create an Aurora
                                                                                                    	// read replica of an RDS MySQL DB instance, the Aurora MySQL DB cluster for the
                                                                                                    	// Aurora read replica is shown. This output does not contain information about
                                                                                                    	// cross region Aurora read replicas. Currently, each RDS DB instance can have only
                                                                                                    	// one Aurora read replica.
                                                                                                    	ReadReplicaDBClusterIdentifiers []string
                                                                                                    
                                                                                                    	// Contains one or more identifiers of the read replicas associated with this DB
                                                                                                    	// instance.
                                                                                                    	ReadReplicaDBInstanceIdentifiers []string
                                                                                                    
                                                                                                    	// Contains the identifier of the source DB instance if this DB instance is a read
                                                                                                    	// replica.
                                                                                                    	ReadReplicaSourceDBInstanceIdentifier *string
                                                                                                    
                                                                                                    	// The open mode of an Oracle read replica. The default is open-read-only. For more
                                                                                                    	// information, see Working with Oracle Read Replicas for Amazon RDS
                                                                                                    	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/oracle-read-replicas.html)
                                                                                                    	// in the Amazon RDS User Guide. This attribute is only supported in RDS for
                                                                                                    	// Oracle.
                                                                                                    	ReplicaMode ReplicaMode
                                                                                                    
                                                                                                    	// If present, specifies the name of the secondary Availability Zone for a DB
                                                                                                    	// instance with multi-AZ support.
                                                                                                    	SecondaryAvailabilityZone *string
                                                                                                    
                                                                                                    	// The status of a read replica. If the instance isn't a read replica, this is
                                                                                                    	// blank.
                                                                                                    	StatusInfos []DBInstanceStatusInfo
                                                                                                    
                                                                                                    	// Specifies whether the DB instance is encrypted.
                                                                                                    	StorageEncrypted bool
                                                                                                    
                                                                                                    	// Specifies the storage type associated with DB instance.
                                                                                                    	StorageType *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.
                                                                                                    	TagList []Tag
                                                                                                    
                                                                                                    	// The ARN from the key store with which the instance is associated for TDE
                                                                                                    	// encryption.
                                                                                                    	TdeCredentialArn *string
                                                                                                    
                                                                                                    	// The time zone of the DB instance. In most cases, the Timezone element is empty.
                                                                                                    	// Timezone content appears only for Microsoft SQL Server DB instances that were
                                                                                                    	// created with a time zone specified.
                                                                                                    	Timezone *string
                                                                                                    
                                                                                                    	// Provides a list of VPC security group elements that the DB instance belongs to.
                                                                                                    	VpcSecurityGroups []VpcSecurityGroupMembership
                                                                                                    }

                                                                                                      Contains the details of an Amazon RDS DB instance. This data type is used as a response element in the DescribeDBInstances action.

                                                                                                      type DBInstanceAlreadyExistsFault

                                                                                                      type DBInstanceAlreadyExistsFault struct {
                                                                                                      	Message *string
                                                                                                      }

                                                                                                        The user already has a DB instance with the given identifier.

                                                                                                        func (*DBInstanceAlreadyExistsFault) Error

                                                                                                        func (*DBInstanceAlreadyExistsFault) ErrorCode

                                                                                                        func (e *DBInstanceAlreadyExistsFault) ErrorCode() string

                                                                                                        func (*DBInstanceAlreadyExistsFault) ErrorFault

                                                                                                        func (*DBInstanceAlreadyExistsFault) ErrorMessage

                                                                                                        func (e *DBInstanceAlreadyExistsFault) ErrorMessage() string

                                                                                                        type DBInstanceAutomatedBackup

                                                                                                        type DBInstanceAutomatedBackup struct {
                                                                                                        
                                                                                                        	// Specifies the allocated storage size in gibibytes (GiB).
                                                                                                        	AllocatedStorage int32
                                                                                                        
                                                                                                        	// The Availability Zone that the automated backup was created in. For information
                                                                                                        	// on AWS Regions and Availability Zones, see Regions and Availability Zones
                                                                                                        	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RegionsAndAvailabilityZones.html).
                                                                                                        	AvailabilityZone *string
                                                                                                        
                                                                                                        	// The retention period for the automated backups.
                                                                                                        	BackupRetentionPeriod *int32
                                                                                                        
                                                                                                        	// The Amazon Resource Name (ARN) for the automated backups.
                                                                                                        	DBInstanceArn *string
                                                                                                        
                                                                                                        	// The Amazon Resource Name (ARN) for the replicated automated backups.
                                                                                                        	DBInstanceAutomatedBackupsArn *string
                                                                                                        
                                                                                                        	// The list of replications to different AWS Regions associated with the automated
                                                                                                        	// backup.
                                                                                                        	DBInstanceAutomatedBackupsReplications []DBInstanceAutomatedBackupsReplication
                                                                                                        
                                                                                                        	// The customer id of the instance that is/was associated with the automated
                                                                                                        	// backup.
                                                                                                        	DBInstanceIdentifier *string
                                                                                                        
                                                                                                        	// The identifier for the source DB instance, which can't be changed and which is
                                                                                                        	// unique to an AWS Region.
                                                                                                        	DbiResourceId *string
                                                                                                        
                                                                                                        	// Specifies whether the automated backup is encrypted.
                                                                                                        	Encrypted bool
                                                                                                        
                                                                                                        	// The name of the database engine for this automated backup.
                                                                                                        	Engine *string
                                                                                                        
                                                                                                        	// The version of the database engine for the automated backup.
                                                                                                        	EngineVersion *string
                                                                                                        
                                                                                                        	// True if mapping of AWS Identity and Access Management (IAM) accounts to database
                                                                                                        	// accounts is enabled, and otherwise false.
                                                                                                        	IAMDatabaseAuthenticationEnabled bool
                                                                                                        
                                                                                                        	// Provides the date and time that the DB instance was created.
                                                                                                        	InstanceCreateTime *time.Time
                                                                                                        
                                                                                                        	// The IOPS (I/O operations per second) value for the automated backup.
                                                                                                        	Iops *int32
                                                                                                        
                                                                                                        	// The AWS KMS key ID for an automated backup. The AWS KMS key identifier is the
                                                                                                        	// key ARN, key ID, alias ARN, or alias name for the AWS KMS customer master key
                                                                                                        	// (CMK).
                                                                                                        	KmsKeyId *string
                                                                                                        
                                                                                                        	// License model information for the automated backup.
                                                                                                        	LicenseModel *string
                                                                                                        
                                                                                                        	// The license model of an automated backup.
                                                                                                        	MasterUsername *string
                                                                                                        
                                                                                                        	// The option group the automated backup is associated with. If omitted, the
                                                                                                        	// default option group for the engine specified is used.
                                                                                                        	OptionGroupName *string
                                                                                                        
                                                                                                        	// The port number that the automated backup used for connections. Default:
                                                                                                        	// Inherits from the source DB instance Valid Values: 1150-65535
                                                                                                        	Port int32
                                                                                                        
                                                                                                        	// The AWS Region associated with the automated backup.
                                                                                                        	Region *string
                                                                                                        
                                                                                                        	// Earliest and latest time an instance can be restored to.
                                                                                                        	RestoreWindow *RestoreWindow
                                                                                                        
                                                                                                        	// Provides a list of status information for an automated backup:
                                                                                                        	//
                                                                                                        	// * 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.
                                                                                                        	Status *string
                                                                                                        
                                                                                                        	// Specifies the storage type associated with the automated backup.
                                                                                                        	StorageType *string
                                                                                                        
                                                                                                        	// The ARN from the key store with which the automated backup is associated for TDE
                                                                                                        	// encryption.
                                                                                                        	TdeCredentialArn *string
                                                                                                        
                                                                                                        	// The time zone of the automated backup. In most cases, the Timezone element is
                                                                                                        	// empty. Timezone content appears only for Microsoft SQL Server DB instances that
                                                                                                        	// were created with a time zone specified.
                                                                                                        	Timezone *string
                                                                                                        
                                                                                                        	// Provides the VPC ID associated with the DB instance
                                                                                                        	VpcId *string
                                                                                                        }

                                                                                                          An automated backup of a DB instance. It consists of system backups, transaction logs, and the database instance properties that existed at the time you deleted the source instance.

                                                                                                          type DBInstanceAutomatedBackupNotFoundFault

                                                                                                          type DBInstanceAutomatedBackupNotFoundFault struct {
                                                                                                          	Message *string
                                                                                                          }

                                                                                                            No automated backup for this DB instance was found.

                                                                                                            func (*DBInstanceAutomatedBackupNotFoundFault) Error

                                                                                                            func (*DBInstanceAutomatedBackupNotFoundFault) ErrorCode

                                                                                                            func (*DBInstanceAutomatedBackupNotFoundFault) ErrorFault

                                                                                                            func (*DBInstanceAutomatedBackupNotFoundFault) ErrorMessage

                                                                                                            type DBInstanceAutomatedBackupQuotaExceededFault

                                                                                                            type DBInstanceAutomatedBackupQuotaExceededFault struct {
                                                                                                            	Message *string
                                                                                                            }

                                                                                                              The quota for retained automated backups was exceeded. This prevents you from retaining any additional automated backups. The retained automated backups quota is the same as your DB Instance quota.

                                                                                                              func (*DBInstanceAutomatedBackupQuotaExceededFault) Error

                                                                                                              func (*DBInstanceAutomatedBackupQuotaExceededFault) ErrorCode

                                                                                                              func (*DBInstanceAutomatedBackupQuotaExceededFault) ErrorFault

                                                                                                              func (*DBInstanceAutomatedBackupQuotaExceededFault) ErrorMessage

                                                                                                              type DBInstanceAutomatedBackupsReplication

                                                                                                              type DBInstanceAutomatedBackupsReplication struct {
                                                                                                              
                                                                                                              	// The Amazon Resource Name (ARN) of the replicated automated backups.
                                                                                                              	DBInstanceAutomatedBackupsArn *string
                                                                                                              }

                                                                                                                Automated backups of a DB instance replicated to another AWS Region. They consist of system backups, transaction logs, and database instance properties.

                                                                                                                type DBInstanceNotFoundFault

                                                                                                                type DBInstanceNotFoundFault struct {
                                                                                                                	Message *string
                                                                                                                }

                                                                                                                  DBInstanceIdentifier doesn't refer to an existing DB instance.

                                                                                                                  func (*DBInstanceNotFoundFault) Error

                                                                                                                  func (e *DBInstanceNotFoundFault) Error() string

                                                                                                                  func (*DBInstanceNotFoundFault) ErrorCode

                                                                                                                  func (e *DBInstanceNotFoundFault) ErrorCode() string

                                                                                                                  func (*DBInstanceNotFoundFault) ErrorFault

                                                                                                                  func (e *DBInstanceNotFoundFault) ErrorFault() smithy.ErrorFault

                                                                                                                  func (*DBInstanceNotFoundFault) ErrorMessage

                                                                                                                  func (e *DBInstanceNotFoundFault) ErrorMessage() string

                                                                                                                  type DBInstanceRole

                                                                                                                  type DBInstanceRole struct {
                                                                                                                  
                                                                                                                  	// The name of the feature associated with the AWS Identity and Access Management
                                                                                                                  	// (IAM) role. For the list of supported feature names, see DBEngineVersion.
                                                                                                                  	FeatureName *string
                                                                                                                  
                                                                                                                  	// The Amazon Resource Name (ARN) of the IAM role that is associated with the DB
                                                                                                                  	// instance.
                                                                                                                  	RoleArn *string
                                                                                                                  
                                                                                                                  	// Describes the state of association between the IAM role and the DB instance. The
                                                                                                                  	// Status property returns one of the following values:
                                                                                                                  	//
                                                                                                                  	// * ACTIVE - the IAM role
                                                                                                                  	// ARN is associated with the DB instance and can be used to access other AWS
                                                                                                                  	// services on your behalf.
                                                                                                                  	//
                                                                                                                  	// * PENDING - the IAM role ARN is being associated with
                                                                                                                  	// the DB instance.
                                                                                                                  	//
                                                                                                                  	// * INVALID - the IAM role ARN is associated with the DB
                                                                                                                  	// instance, but the DB instance is unable to assume the IAM role in order to
                                                                                                                  	// access other AWS services on your behalf.
                                                                                                                  	Status *string
                                                                                                                  }

                                                                                                                    Describes an AWS Identity and Access Management (IAM) role that is associated with a DB instance.

                                                                                                                    type DBInstanceRoleAlreadyExistsFault

                                                                                                                    type DBInstanceRoleAlreadyExistsFault struct {
                                                                                                                    	Message *string
                                                                                                                    }

                                                                                                                      The specified RoleArn or FeatureName value is already associated with the DB instance.

                                                                                                                      func (*DBInstanceRoleAlreadyExistsFault) Error

                                                                                                                      func (*DBInstanceRoleAlreadyExistsFault) ErrorCode

                                                                                                                      func (*DBInstanceRoleAlreadyExistsFault) ErrorFault

                                                                                                                      func (*DBInstanceRoleAlreadyExistsFault) ErrorMessage

                                                                                                                      func (e *DBInstanceRoleAlreadyExistsFault) ErrorMessage() string

                                                                                                                      type DBInstanceRoleNotFoundFault

                                                                                                                      type DBInstanceRoleNotFoundFault struct {
                                                                                                                      	Message *string
                                                                                                                      }

                                                                                                                        The specified RoleArn value doesn't match the specified feature for the DB instance.

                                                                                                                        func (*DBInstanceRoleNotFoundFault) Error

                                                                                                                        func (*DBInstanceRoleNotFoundFault) ErrorCode

                                                                                                                        func (e *DBInstanceRoleNotFoundFault) ErrorCode() string

                                                                                                                        func (*DBInstanceRoleNotFoundFault) ErrorFault

                                                                                                                        func (*DBInstanceRoleNotFoundFault) ErrorMessage

                                                                                                                        func (e *DBInstanceRoleNotFoundFault) ErrorMessage() string

                                                                                                                        type DBInstanceRoleQuotaExceededFault

                                                                                                                        type DBInstanceRoleQuotaExceededFault struct {
                                                                                                                        	Message *string
                                                                                                                        }

                                                                                                                          You can't associate any more AWS Identity and Access Management (IAM) roles with the DB instance because the quota has been reached.

                                                                                                                          func (*DBInstanceRoleQuotaExceededFault) Error

                                                                                                                          func (*DBInstanceRoleQuotaExceededFault) ErrorCode

                                                                                                                          func (*DBInstanceRoleQuotaExceededFault) ErrorFault

                                                                                                                          func (*DBInstanceRoleQuotaExceededFault) ErrorMessage

                                                                                                                          func (e *DBInstanceRoleQuotaExceededFault) ErrorMessage() string

                                                                                                                          type DBInstanceStatusInfo

                                                                                                                          type DBInstanceStatusInfo struct {
                                                                                                                          
                                                                                                                          	// Details of the error if there is an error for the instance. If the instance
                                                                                                                          	// isn't in an error state, this value is blank.
                                                                                                                          	Message *string
                                                                                                                          
                                                                                                                          	// Boolean value that is true if the instance is operating normally, or false if
                                                                                                                          	// the instance is in an error state.
                                                                                                                          	Normal bool
                                                                                                                          
                                                                                                                          	// Status of the DB instance. For a StatusType of read replica, the values can be
                                                                                                                          	// replicating, replication stop point set, replication stop point reached, error,
                                                                                                                          	// stopped, or terminated.
                                                                                                                          	Status *string
                                                                                                                          
                                                                                                                          	// This value is currently "read replication."
                                                                                                                          	StatusType *string
                                                                                                                          }

                                                                                                                            Provides a list of status information for a DB instance.

                                                                                                                            type DBLogFileNotFoundFault

                                                                                                                            type DBLogFileNotFoundFault struct {
                                                                                                                            	Message *string
                                                                                                                            }

                                                                                                                              LogFileName doesn't refer to an existing DB log file.

                                                                                                                              func (*DBLogFileNotFoundFault) Error

                                                                                                                              func (e *DBLogFileNotFoundFault) Error() string

                                                                                                                              func (*DBLogFileNotFoundFault) ErrorCode

                                                                                                                              func (e *DBLogFileNotFoundFault) ErrorCode() string

                                                                                                                              func (*DBLogFileNotFoundFault) ErrorFault

                                                                                                                              func (e *DBLogFileNotFoundFault) ErrorFault() smithy.ErrorFault

                                                                                                                              func (*DBLogFileNotFoundFault) ErrorMessage

                                                                                                                              func (e *DBLogFileNotFoundFault) ErrorMessage() string

                                                                                                                              type DBParameterGroup

                                                                                                                              type DBParameterGroup struct {
                                                                                                                              
                                                                                                                              	// The Amazon Resource Name (ARN) for the DB parameter group.
                                                                                                                              	DBParameterGroupArn *string
                                                                                                                              
                                                                                                                              	// The name of the DB parameter group family that this DB parameter group is
                                                                                                                              	// compatible with.
                                                                                                                              	DBParameterGroupFamily *string
                                                                                                                              
                                                                                                                              	// The name of the DB parameter group.
                                                                                                                              	DBParameterGroupName *string
                                                                                                                              
                                                                                                                              	// Provides the customer-specified description for this DB parameter group.
                                                                                                                              	Description *string
                                                                                                                              }

                                                                                                                                Contains the details of an Amazon RDS DB parameter group. This data type is used as a response element in the DescribeDBParameterGroups action.

                                                                                                                                type DBParameterGroupAlreadyExistsFault

                                                                                                                                type DBParameterGroupAlreadyExistsFault struct {
                                                                                                                                	Message *string
                                                                                                                                }

                                                                                                                                  A DB parameter group with the same name exists.

                                                                                                                                  func (*DBParameterGroupAlreadyExistsFault) Error

                                                                                                                                  func (*DBParameterGroupAlreadyExistsFault) ErrorCode

                                                                                                                                  func (*DBParameterGroupAlreadyExistsFault) ErrorFault

                                                                                                                                  func (*DBParameterGroupAlreadyExistsFault) ErrorMessage

                                                                                                                                  func (e *DBParameterGroupAlreadyExistsFault) ErrorMessage() string

                                                                                                                                  type DBParameterGroupNotFoundFault

                                                                                                                                  type DBParameterGroupNotFoundFault struct {
                                                                                                                                  	Message *string
                                                                                                                                  }

                                                                                                                                    DBParameterGroupName doesn't refer to an existing DB parameter group.

                                                                                                                                    func (*DBParameterGroupNotFoundFault) Error

                                                                                                                                    func (*DBParameterGroupNotFoundFault) ErrorCode

                                                                                                                                    func (e *DBParameterGroupNotFoundFault) ErrorCode() string

                                                                                                                                    func (*DBParameterGroupNotFoundFault) ErrorFault

                                                                                                                                    func (*DBParameterGroupNotFoundFault) ErrorMessage

                                                                                                                                    func (e *DBParameterGroupNotFoundFault) ErrorMessage() string

                                                                                                                                    type DBParameterGroupQuotaExceededFault

                                                                                                                                    type DBParameterGroupQuotaExceededFault struct {
                                                                                                                                    	Message *string
                                                                                                                                    }

                                                                                                                                      The request would result in the user exceeding the allowed number of DB parameter groups.

                                                                                                                                      func (*DBParameterGroupQuotaExceededFault) Error

                                                                                                                                      func (*DBParameterGroupQuotaExceededFault) ErrorCode

                                                                                                                                      func (*DBParameterGroupQuotaExceededFault) ErrorFault

                                                                                                                                      func (*DBParameterGroupQuotaExceededFault) ErrorMessage

                                                                                                                                      func (e *DBParameterGroupQuotaExceededFault) ErrorMessage() string

                                                                                                                                      type DBParameterGroupStatus

                                                                                                                                      type DBParameterGroupStatus struct {
                                                                                                                                      
                                                                                                                                      	// The name of the DB parameter group.
                                                                                                                                      	DBParameterGroupName *string
                                                                                                                                      
                                                                                                                                      	// The status of parameter updates.
                                                                                                                                      	ParameterApplyStatus *string
                                                                                                                                      }

                                                                                                                                        The status of the DB parameter group. This data type is used as a response element in the following actions:

                                                                                                                                        * CreateDBInstance

                                                                                                                                        * CreateDBInstanceReadReplica

                                                                                                                                        * DeleteDBInstance

                                                                                                                                        * ModifyDBInstance

                                                                                                                                        * RebootDBInstance

                                                                                                                                        * RestoreDBInstanceFromDBSnapshot

                                                                                                                                        type DBProxy

                                                                                                                                        type DBProxy struct {
                                                                                                                                        
                                                                                                                                        	// One or more data structures specifying the authorization mechanism to connect to
                                                                                                                                        	// the associated RDS DB instance or Aurora DB cluster.
                                                                                                                                        	Auth []UserAuthConfigInfo
                                                                                                                                        
                                                                                                                                        	// The date and time when the proxy was first created.
                                                                                                                                        	CreatedDate *time.Time
                                                                                                                                        
                                                                                                                                        	// The Amazon Resource Name (ARN) for the proxy.
                                                                                                                                        	DBProxyArn *string
                                                                                                                                        
                                                                                                                                        	// The identifier for the proxy. This name must be unique for all proxies owned by
                                                                                                                                        	// your AWS account in the specified AWS Region.
                                                                                                                                        	DBProxyName *string
                                                                                                                                        
                                                                                                                                        	// 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 endpoint that you can use to connect to the proxy. You include the endpoint
                                                                                                                                        	// value in the connection string for a database client application.
                                                                                                                                        	Endpoint *string
                                                                                                                                        
                                                                                                                                        	// The engine family applies to MySQL and PostgreSQL for both RDS and Aurora.
                                                                                                                                        	EngineFamily *string
                                                                                                                                        
                                                                                                                                        	// The number of seconds a connection to the proxy can have no activity before the
                                                                                                                                        	// proxy drops the client connection. The proxy keeps the underlying database
                                                                                                                                        	// connection open and puts it back into the connection pool for reuse by later
                                                                                                                                        	// connection requests. Default: 1800 (30 minutes) Constraints: 1 to 28,800
                                                                                                                                        	IdleClientTimeout int32
                                                                                                                                        
                                                                                                                                        	// Indicates whether Transport Layer Security (TLS) encryption is required for
                                                                                                                                        	// connections to the proxy.
                                                                                                                                        	RequireTLS bool
                                                                                                                                        
                                                                                                                                        	// The Amazon Resource Name (ARN) for the IAM role that the proxy uses to access
                                                                                                                                        	// Amazon Secrets Manager.
                                                                                                                                        	RoleArn *string
                                                                                                                                        
                                                                                                                                        	// The current status of this proxy. A status of available means the proxy is ready
                                                                                                                                        	// to handle requests. Other values indicate that you must wait for the proxy to be
                                                                                                                                        	// ready, or take some action to resolve an issue.
                                                                                                                                        	Status DBProxyStatus
                                                                                                                                        
                                                                                                                                        	// The date and time when the proxy was last updated.
                                                                                                                                        	UpdatedDate *time.Time
                                                                                                                                        
                                                                                                                                        	// Provides a list of VPC security groups that the proxy belongs to.
                                                                                                                                        	VpcSecurityGroupIds []string
                                                                                                                                        
                                                                                                                                        	// The EC2 subnet IDs for the proxy.
                                                                                                                                        	VpcSubnetIds []string
                                                                                                                                        }

                                                                                                                                          The data structure representing a proxy managed by the RDS Proxy. This data type is used as a response element in the DescribeDBProxies action.

                                                                                                                                          type DBProxyAlreadyExistsFault

                                                                                                                                          type DBProxyAlreadyExistsFault struct {
                                                                                                                                          	Message *string
                                                                                                                                          }

                                                                                                                                            The specified proxy name must be unique for all proxies owned by your AWS account in the specified AWS Region.

                                                                                                                                            func (*DBProxyAlreadyExistsFault) Error

                                                                                                                                            func (e *DBProxyAlreadyExistsFault) Error() string

                                                                                                                                            func (*DBProxyAlreadyExistsFault) ErrorCode

                                                                                                                                            func (e *DBProxyAlreadyExistsFault) ErrorCode() string

                                                                                                                                            func (*DBProxyAlreadyExistsFault) ErrorFault

                                                                                                                                            func (*DBProxyAlreadyExistsFault) ErrorMessage

                                                                                                                                            func (e *DBProxyAlreadyExistsFault) ErrorMessage() string

                                                                                                                                            type DBProxyNotFoundFault

                                                                                                                                            type DBProxyNotFoundFault struct {
                                                                                                                                            	Message *string
                                                                                                                                            }

                                                                                                                                              The specified proxy name doesn't correspond to a proxy owned by your AWS account in the specified AWS Region.

                                                                                                                                              func (*DBProxyNotFoundFault) Error

                                                                                                                                              func (e *DBProxyNotFoundFault) Error() string

                                                                                                                                              func (*DBProxyNotFoundFault) ErrorCode

                                                                                                                                              func (e *DBProxyNotFoundFault) ErrorCode() string

                                                                                                                                              func (*DBProxyNotFoundFault) ErrorFault

                                                                                                                                              func (e *DBProxyNotFoundFault) ErrorFault() smithy.ErrorFault

                                                                                                                                              func (*DBProxyNotFoundFault) ErrorMessage

                                                                                                                                              func (e *DBProxyNotFoundFault) ErrorMessage() string

                                                                                                                                              type DBProxyQuotaExceededFault

                                                                                                                                              type DBProxyQuotaExceededFault struct {
                                                                                                                                              	Message *string
                                                                                                                                              }

                                                                                                                                                Your AWS account already has the maximum number of proxies in the specified AWS Region.

                                                                                                                                                func (*DBProxyQuotaExceededFault) Error

                                                                                                                                                func (e *DBProxyQuotaExceededFault) Error() string

                                                                                                                                                func (*DBProxyQuotaExceededFault) ErrorCode

                                                                                                                                                func (e *DBProxyQuotaExceededFault) ErrorCode() string

                                                                                                                                                func (*DBProxyQuotaExceededFault) ErrorFault

                                                                                                                                                func (*DBProxyQuotaExceededFault) ErrorMessage

                                                                                                                                                func (e *DBProxyQuotaExceededFault) ErrorMessage() string

                                                                                                                                                type DBProxyStatus

                                                                                                                                                type DBProxyStatus string
                                                                                                                                                const (
                                                                                                                                                	DBProxyStatusAvailable                  DBProxyStatus = "available"
                                                                                                                                                	DBProxyStatusModifying                  DBProxyStatus = "modifying"
                                                                                                                                                	DBProxyStatusIncompatibleNetwork        DBProxyStatus = "incompatible-network"
                                                                                                                                                	DBProxyStatusInsufficientResourceLimits DBProxyStatus = "insufficient-resource-limits"
                                                                                                                                                	DBProxyStatusCreating                   DBProxyStatus = "creating"
                                                                                                                                                	DBProxyStatusDeleting                   DBProxyStatus = "deleting"
                                                                                                                                                	DBProxyStatusSuspended                  DBProxyStatus = "suspended"
                                                                                                                                                	DBProxyStatusSuspending                 DBProxyStatus = "suspending"
                                                                                                                                                	DBProxyStatusReactivating               DBProxyStatus = "reactivating"
                                                                                                                                                )

                                                                                                                                                  Enum values for DBProxyStatus

                                                                                                                                                  func (DBProxyStatus) Values

                                                                                                                                                  func (DBProxyStatus) Values() []DBProxyStatus

                                                                                                                                                    Values returns all known values for DBProxyStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                    type DBProxyTarget

                                                                                                                                                    type DBProxyTarget struct {
                                                                                                                                                    
                                                                                                                                                    	// The writer endpoint for the RDS DB instance or Aurora DB cluster.
                                                                                                                                                    	Endpoint *string
                                                                                                                                                    
                                                                                                                                                    	// The port that the RDS Proxy uses to connect to the target RDS DB instance or
                                                                                                                                                    	// Aurora DB cluster.
                                                                                                                                                    	Port int32
                                                                                                                                                    
                                                                                                                                                    	// The identifier representing the target. It can be the instance identifier for an
                                                                                                                                                    	// RDS DB instance, or the cluster identifier for an Aurora DB cluster.
                                                                                                                                                    	RdsResourceId *string
                                                                                                                                                    
                                                                                                                                                    	// The Amazon Resource Name (ARN) for the RDS DB instance or Aurora DB cluster.
                                                                                                                                                    	TargetArn *string
                                                                                                                                                    
                                                                                                                                                    	// Information about the connection health of the RDS Proxy target.
                                                                                                                                                    	TargetHealth *TargetHealth
                                                                                                                                                    
                                                                                                                                                    	// The DB cluster identifier when the target represents an Aurora DB cluster. This
                                                                                                                                                    	// field is blank when the target represents an RDS DB instance.
                                                                                                                                                    	TrackedClusterId *string
                                                                                                                                                    
                                                                                                                                                    	// Specifies the kind of database, such as an RDS DB instance or an Aurora DB
                                                                                                                                                    	// cluster, that the target represents.
                                                                                                                                                    	Type TargetType
                                                                                                                                                    }

                                                                                                                                                      Contains the details for an RDS Proxy target. It represents an RDS DB instance or Aurora DB cluster that the proxy can connect to. One or more targets are associated with an RDS Proxy target group. This data type is used as a response element in the DescribeDBProxyTargets action.

                                                                                                                                                      type DBProxyTargetAlreadyRegisteredFault

                                                                                                                                                      type DBProxyTargetAlreadyRegisteredFault struct {
                                                                                                                                                      	Message *string
                                                                                                                                                      }

                                                                                                                                                        The proxy is already associated with the specified RDS DB instance or Aurora DB cluster.

                                                                                                                                                        func (*DBProxyTargetAlreadyRegisteredFault) Error

                                                                                                                                                        func (*DBProxyTargetAlreadyRegisteredFault) ErrorCode

                                                                                                                                                        func (*DBProxyTargetAlreadyRegisteredFault) ErrorFault

                                                                                                                                                        func (*DBProxyTargetAlreadyRegisteredFault) ErrorMessage

                                                                                                                                                        func (e *DBProxyTargetAlreadyRegisteredFault) ErrorMessage() string

                                                                                                                                                        type DBProxyTargetGroup

                                                                                                                                                        type DBProxyTargetGroup struct {
                                                                                                                                                        
                                                                                                                                                        	// The settings that determine the size and behavior of the connection pool for the
                                                                                                                                                        	// target group.
                                                                                                                                                        	ConnectionPoolConfig *ConnectionPoolConfigurationInfo
                                                                                                                                                        
                                                                                                                                                        	// The date and time when the target group was first created.
                                                                                                                                                        	CreatedDate *time.Time
                                                                                                                                                        
                                                                                                                                                        	// The identifier for the RDS proxy associated with this target group.
                                                                                                                                                        	DBProxyName *string
                                                                                                                                                        
                                                                                                                                                        	// Whether this target group is the first one used for connection requests by the
                                                                                                                                                        	// associated proxy. Because each proxy is currently associated with a single
                                                                                                                                                        	// target group, currently this setting is always true.
                                                                                                                                                        	IsDefault bool
                                                                                                                                                        
                                                                                                                                                        	// The current status of this target group. A status of available means the target
                                                                                                                                                        	// group is correctly associated with a database. Other values indicate that you
                                                                                                                                                        	// must wait for the target group to be ready, or take some action to resolve an
                                                                                                                                                        	// issue.
                                                                                                                                                        	Status *string
                                                                                                                                                        
                                                                                                                                                        	// The Amazon Resource Name (ARN) representing the target group.
                                                                                                                                                        	TargetGroupArn *string
                                                                                                                                                        
                                                                                                                                                        	// The identifier for the target group. This name must be unique for all target
                                                                                                                                                        	// groups owned by your AWS account in the specified AWS Region.
                                                                                                                                                        	TargetGroupName *string
                                                                                                                                                        
                                                                                                                                                        	// The date and time when the target group was last updated.
                                                                                                                                                        	UpdatedDate *time.Time
                                                                                                                                                        }

                                                                                                                                                          Represents a set of RDS DB instances, Aurora DB clusters, or both that a proxy can connect to. Currently, each target group is associated with exactly one RDS DB instance or Aurora DB cluster. This data type is used as a response element in the DescribeDBProxyTargetGroups action.

                                                                                                                                                          type DBProxyTargetGroupNotFoundFault

                                                                                                                                                          type DBProxyTargetGroupNotFoundFault struct {
                                                                                                                                                          	Message *string
                                                                                                                                                          }

                                                                                                                                                            The specified target group isn't available for a proxy owned by your AWS account in the specified AWS Region.

                                                                                                                                                            func (*DBProxyTargetGroupNotFoundFault) Error

                                                                                                                                                            func (*DBProxyTargetGroupNotFoundFault) ErrorCode

                                                                                                                                                            func (e *DBProxyTargetGroupNotFoundFault) ErrorCode() string

                                                                                                                                                            func (*DBProxyTargetGroupNotFoundFault) ErrorFault

                                                                                                                                                            func (*DBProxyTargetGroupNotFoundFault) ErrorMessage

                                                                                                                                                            func (e *DBProxyTargetGroupNotFoundFault) ErrorMessage() string

                                                                                                                                                            type DBProxyTargetNotFoundFault

                                                                                                                                                            type DBProxyTargetNotFoundFault struct {
                                                                                                                                                            	Message *string
                                                                                                                                                            }

                                                                                                                                                              The specified RDS DB instance or Aurora DB cluster isn't available for a proxy owned by your AWS account in the specified AWS Region.

                                                                                                                                                              func (*DBProxyTargetNotFoundFault) Error

                                                                                                                                                              func (*DBProxyTargetNotFoundFault) ErrorCode

                                                                                                                                                              func (e *DBProxyTargetNotFoundFault) ErrorCode() string

                                                                                                                                                              func (*DBProxyTargetNotFoundFault) ErrorFault

                                                                                                                                                              func (*DBProxyTargetNotFoundFault) ErrorMessage

                                                                                                                                                              func (e *DBProxyTargetNotFoundFault) ErrorMessage() string

                                                                                                                                                              type DBSecurityGroup

                                                                                                                                                              type DBSecurityGroup struct {
                                                                                                                                                              
                                                                                                                                                              	// The Amazon Resource Name (ARN) for the DB security group.
                                                                                                                                                              	DBSecurityGroupArn *string
                                                                                                                                                              
                                                                                                                                                              	// Provides the description of the DB security group.
                                                                                                                                                              	DBSecurityGroupDescription *string
                                                                                                                                                              
                                                                                                                                                              	// Specifies the name of the DB security group.
                                                                                                                                                              	DBSecurityGroupName *string
                                                                                                                                                              
                                                                                                                                                              	// Contains a list of EC2SecurityGroup elements.
                                                                                                                                                              	EC2SecurityGroups []EC2SecurityGroup
                                                                                                                                                              
                                                                                                                                                              	// Contains a list of IPRange elements.
                                                                                                                                                              	IPRanges []IPRange
                                                                                                                                                              
                                                                                                                                                              	// Provides the AWS ID of the owner of a specific DB security group.
                                                                                                                                                              	OwnerId *string
                                                                                                                                                              
                                                                                                                                                              	// Provides the VpcId of the DB security group.
                                                                                                                                                              	VpcId *string
                                                                                                                                                              }

                                                                                                                                                                Contains the details for an Amazon RDS DB security group. This data type is used as a response element in the DescribeDBSecurityGroups action.

                                                                                                                                                                type DBSecurityGroupAlreadyExistsFault

                                                                                                                                                                type DBSecurityGroupAlreadyExistsFault struct {
                                                                                                                                                                	Message *string
                                                                                                                                                                }

                                                                                                                                                                  A DB security group with the name specified in DBSecurityGroupName already exists.

                                                                                                                                                                  func (*DBSecurityGroupAlreadyExistsFault) Error

                                                                                                                                                                  func (*DBSecurityGroupAlreadyExistsFault) ErrorCode

                                                                                                                                                                  func (*DBSecurityGroupAlreadyExistsFault) ErrorFault

                                                                                                                                                                  func (*DBSecurityGroupAlreadyExistsFault) ErrorMessage

                                                                                                                                                                  func (e *DBSecurityGroupAlreadyExistsFault) ErrorMessage() string

                                                                                                                                                                  type DBSecurityGroupMembership

                                                                                                                                                                  type DBSecurityGroupMembership struct {
                                                                                                                                                                  
                                                                                                                                                                  	// The name of the DB security group.
                                                                                                                                                                  	DBSecurityGroupName *string
                                                                                                                                                                  
                                                                                                                                                                  	// The status of the DB security group.
                                                                                                                                                                  	Status *string
                                                                                                                                                                  }

                                                                                                                                                                    This data type is used as a response element in the following actions:

                                                                                                                                                                    * ModifyDBInstance

                                                                                                                                                                    * RebootDBInstance

                                                                                                                                                                    * RestoreDBInstanceFromDBSnapshot

                                                                                                                                                                    * RestoreDBInstanceToPointInTime

                                                                                                                                                                    type DBSecurityGroupNotFoundFault

                                                                                                                                                                    type DBSecurityGroupNotFoundFault struct {
                                                                                                                                                                    	Message *string
                                                                                                                                                                    }

                                                                                                                                                                      DBSecurityGroupName doesn't refer to an existing DB security group.

                                                                                                                                                                      func (*DBSecurityGroupNotFoundFault) Error

                                                                                                                                                                      func (*DBSecurityGroupNotFoundFault) ErrorCode

                                                                                                                                                                      func (e *DBSecurityGroupNotFoundFault) ErrorCode() string

                                                                                                                                                                      func (*DBSecurityGroupNotFoundFault) ErrorFault

                                                                                                                                                                      func (*DBSecurityGroupNotFoundFault) ErrorMessage

                                                                                                                                                                      func (e *DBSecurityGroupNotFoundFault) ErrorMessage() string

                                                                                                                                                                      type DBSecurityGroupNotSupportedFault

                                                                                                                                                                      type DBSecurityGroupNotSupportedFault struct {
                                                                                                                                                                      	Message *string
                                                                                                                                                                      }

                                                                                                                                                                        A DB security group isn't allowed for this action.

                                                                                                                                                                        func (*DBSecurityGroupNotSupportedFault) Error

                                                                                                                                                                        func (*DBSecurityGroupNotSupportedFault) ErrorCode

                                                                                                                                                                        func (*DBSecurityGroupNotSupportedFault) ErrorFault

                                                                                                                                                                        func (*DBSecurityGroupNotSupportedFault) ErrorMessage

                                                                                                                                                                        func (e *DBSecurityGroupNotSupportedFault) ErrorMessage() string

                                                                                                                                                                        type DBSecurityGroupQuotaExceededFault

                                                                                                                                                                        type DBSecurityGroupQuotaExceededFault struct {
                                                                                                                                                                        	Message *string
                                                                                                                                                                        }

                                                                                                                                                                          The request would result in the user exceeding the allowed number of DB security groups.

                                                                                                                                                                          func (*DBSecurityGroupQuotaExceededFault) Error

                                                                                                                                                                          func (*DBSecurityGroupQuotaExceededFault) ErrorCode

                                                                                                                                                                          func (*DBSecurityGroupQuotaExceededFault) ErrorFault

                                                                                                                                                                          func (*DBSecurityGroupQuotaExceededFault) ErrorMessage

                                                                                                                                                                          func (e *DBSecurityGroupQuotaExceededFault) ErrorMessage() string

                                                                                                                                                                          type DBSnapshot

                                                                                                                                                                          type DBSnapshot struct {
                                                                                                                                                                          
                                                                                                                                                                          	// Specifies the allocated storage size in gibibytes (GiB).
                                                                                                                                                                          	AllocatedStorage int32
                                                                                                                                                                          
                                                                                                                                                                          	// Specifies the name of the Availability Zone the DB instance was located in at
                                                                                                                                                                          	// the time of the DB snapshot.
                                                                                                                                                                          	AvailabilityZone *string
                                                                                                                                                                          
                                                                                                                                                                          	// Specifies the DB instance identifier of the DB instance this DB snapshot was
                                                                                                                                                                          	// created from.
                                                                                                                                                                          	DBInstanceIdentifier *string
                                                                                                                                                                          
                                                                                                                                                                          	// The Amazon Resource Name (ARN) for the DB snapshot.
                                                                                                                                                                          	DBSnapshotArn *string
                                                                                                                                                                          
                                                                                                                                                                          	// Specifies the identifier for the DB snapshot.
                                                                                                                                                                          	DBSnapshotIdentifier *string
                                                                                                                                                                          
                                                                                                                                                                          	// The identifier for the source DB instance, which can't be changed and which is
                                                                                                                                                                          	// unique to an AWS Region.
                                                                                                                                                                          	DbiResourceId *string
                                                                                                                                                                          
                                                                                                                                                                          	// Specifies whether the DB snapshot is encrypted.
                                                                                                                                                                          	Encrypted bool
                                                                                                                                                                          
                                                                                                                                                                          	// Specifies the name of the database engine.
                                                                                                                                                                          	Engine *string
                                                                                                                                                                          
                                                                                                                                                                          	// Specifies the version of the database engine.
                                                                                                                                                                          	EngineVersion *string
                                                                                                                                                                          
                                                                                                                                                                          	// True if mapping of AWS Identity and Access Management (IAM) accounts to database
                                                                                                                                                                          	// accounts is enabled, and otherwise false.
                                                                                                                                                                          	IAMDatabaseAuthenticationEnabled bool
                                                                                                                                                                          
                                                                                                                                                                          	// Specifies the time in Coordinated Universal Time (UTC) when the DB instance,
                                                                                                                                                                          	// from which the snapshot was taken, was created.
                                                                                                                                                                          	InstanceCreateTime *time.Time
                                                                                                                                                                          
                                                                                                                                                                          	// Specifies the Provisioned IOPS (I/O operations per second) value of the DB
                                                                                                                                                                          	// instance at the time of the snapshot.
                                                                                                                                                                          	Iops *int32
                                                                                                                                                                          
                                                                                                                                                                          	// If Encrypted is true, the AWS KMS key identifier for the encrypted DB snapshot.
                                                                                                                                                                          	// The AWS KMS key identifier is the key ARN, key ID, alias ARN, or alias name for
                                                                                                                                                                          	// the AWS KMS customer master key (CMK).
                                                                                                                                                                          	KmsKeyId *string
                                                                                                                                                                          
                                                                                                                                                                          	// License model information for the restored DB instance.
                                                                                                                                                                          	LicenseModel *string
                                                                                                                                                                          
                                                                                                                                                                          	// Provides the master username for the DB snapshot.
                                                                                                                                                                          	MasterUsername *string
                                                                                                                                                                          
                                                                                                                                                                          	// Provides the option group name for the DB snapshot.
                                                                                                                                                                          	OptionGroupName *string
                                                                                                                                                                          
                                                                                                                                                                          	// The percentage of the estimated data that has been transferred.
                                                                                                                                                                          	PercentProgress int32
                                                                                                                                                                          
                                                                                                                                                                          	// Specifies the port that the database engine was listening on at the time of the
                                                                                                                                                                          	// snapshot.
                                                                                                                                                                          	Port int32
                                                                                                                                                                          
                                                                                                                                                                          	// The number of CPU cores and the number of threads per core for the DB instance
                                                                                                                                                                          	// class of the DB instance when the DB snapshot was created.
                                                                                                                                                                          	ProcessorFeatures []ProcessorFeature
                                                                                                                                                                          
                                                                                                                                                                          	// Specifies when the snapshot was taken in Coordinated Universal Time (UTC).
                                                                                                                                                                          	SnapshotCreateTime *time.Time
                                                                                                                                                                          
                                                                                                                                                                          	// Provides the type of the DB snapshot.
                                                                                                                                                                          	SnapshotType *string
                                                                                                                                                                          
                                                                                                                                                                          	// The DB snapshot Amazon Resource Name (ARN) that the DB snapshot was copied from.
                                                                                                                                                                          	// It only has value in case of cross-customer or cross-region copy.
                                                                                                                                                                          	SourceDBSnapshotIdentifier *string
                                                                                                                                                                          
                                                                                                                                                                          	// The AWS Region that the DB snapshot was created in or copied from.
                                                                                                                                                                          	SourceRegion *string
                                                                                                                                                                          
                                                                                                                                                                          	// Specifies the status of this DB snapshot.
                                                                                                                                                                          	Status *string
                                                                                                                                                                          
                                                                                                                                                                          	// Specifies the storage type associated with DB snapshot.
                                                                                                                                                                          	StorageType *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.
                                                                                                                                                                          	TagList []Tag
                                                                                                                                                                          
                                                                                                                                                                          	// The ARN from the key store with which to associate the instance for TDE
                                                                                                                                                                          	// encryption.
                                                                                                                                                                          	TdeCredentialArn *string
                                                                                                                                                                          
                                                                                                                                                                          	// The time zone of the DB snapshot. In most cases, the Timezone element is empty.
                                                                                                                                                                          	// Timezone content appears only for snapshots taken from Microsoft SQL Server DB
                                                                                                                                                                          	// instances that were created with a time zone specified.
                                                                                                                                                                          	Timezone *string
                                                                                                                                                                          
                                                                                                                                                                          	// Provides the VPC ID associated with the DB snapshot.
                                                                                                                                                                          	VpcId *string
                                                                                                                                                                          }

                                                                                                                                                                            Contains the details of an Amazon RDS DB snapshot. This data type is used as a response element in the DescribeDBSnapshots action.

                                                                                                                                                                            type DBSnapshotAlreadyExistsFault

                                                                                                                                                                            type DBSnapshotAlreadyExistsFault struct {
                                                                                                                                                                            	Message *string
                                                                                                                                                                            }

                                                                                                                                                                              DBSnapshotIdentifier is already used by an existing snapshot.

                                                                                                                                                                              func (*DBSnapshotAlreadyExistsFault) Error

                                                                                                                                                                              func (*DBSnapshotAlreadyExistsFault) ErrorCode

                                                                                                                                                                              func (e *DBSnapshotAlreadyExistsFault) ErrorCode() string

                                                                                                                                                                              func (*DBSnapshotAlreadyExistsFault) ErrorFault

                                                                                                                                                                              func (*DBSnapshotAlreadyExistsFault) ErrorMessage

                                                                                                                                                                              func (e *DBSnapshotAlreadyExistsFault) ErrorMessage() string

                                                                                                                                                                              type DBSnapshotAttribute

                                                                                                                                                                              type DBSnapshotAttribute struct {
                                                                                                                                                                              
                                                                                                                                                                              	// The name of the manual DB snapshot attribute. The attribute named restore refers
                                                                                                                                                                              	// to the list of AWS accounts that have permission to copy or restore the manual
                                                                                                                                                                              	// DB cluster snapshot. For more information, see the ModifyDBSnapshotAttribute API
                                                                                                                                                                              	// action.
                                                                                                                                                                              	AttributeName *string
                                                                                                                                                                              
                                                                                                                                                                              	// The value or values for the manual DB snapshot attribute. If the AttributeName
                                                                                                                                                                              	// field is set to restore, then this element returns a list of IDs of the AWS
                                                                                                                                                                              	// accounts that are authorized to copy or restore the manual DB snapshot. If a
                                                                                                                                                                              	// value of all is in the list, then the manual DB snapshot is public and available
                                                                                                                                                                              	// for any AWS account to copy or restore.
                                                                                                                                                                              	AttributeValues []string
                                                                                                                                                                              }

                                                                                                                                                                                Contains the name and values of a manual DB snapshot attribute Manual DB snapshot attributes are used to authorize other AWS accounts to restore a manual DB snapshot. For more information, see the ModifyDBSnapshotAttribute API.

                                                                                                                                                                                type DBSnapshotAttributesResult

                                                                                                                                                                                type DBSnapshotAttributesResult struct {
                                                                                                                                                                                
                                                                                                                                                                                	// The list of attributes and values for the manual DB snapshot.
                                                                                                                                                                                	DBSnapshotAttributes []DBSnapshotAttribute
                                                                                                                                                                                
                                                                                                                                                                                	// The identifier of the manual DB snapshot that the attributes apply to.
                                                                                                                                                                                	DBSnapshotIdentifier *string
                                                                                                                                                                                }

                                                                                                                                                                                  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.

                                                                                                                                                                                  type DBSnapshotNotFoundFault

                                                                                                                                                                                  type DBSnapshotNotFoundFault struct {
                                                                                                                                                                                  	Message *string
                                                                                                                                                                                  }

                                                                                                                                                                                    DBSnapshotIdentifier doesn't refer to an existing DB snapshot.

                                                                                                                                                                                    func (*DBSnapshotNotFoundFault) Error

                                                                                                                                                                                    func (e *DBSnapshotNotFoundFault) Error() string

                                                                                                                                                                                    func (*DBSnapshotNotFoundFault) ErrorCode

                                                                                                                                                                                    func (e *DBSnapshotNotFoundFault) ErrorCode() string

                                                                                                                                                                                    func (*DBSnapshotNotFoundFault) ErrorFault

                                                                                                                                                                                    func (e *DBSnapshotNotFoundFault) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                    func (*DBSnapshotNotFoundFault) ErrorMessage

                                                                                                                                                                                    func (e *DBSnapshotNotFoundFault) ErrorMessage() string

                                                                                                                                                                                    type DBSubnetGroup

                                                                                                                                                                                    type DBSubnetGroup struct {
                                                                                                                                                                                    
                                                                                                                                                                                    	// The Amazon Resource Name (ARN) for the DB subnet group.
                                                                                                                                                                                    	DBSubnetGroupArn *string
                                                                                                                                                                                    
                                                                                                                                                                                    	// Provides the description of the DB subnet group.
                                                                                                                                                                                    	DBSubnetGroupDescription *string
                                                                                                                                                                                    
                                                                                                                                                                                    	// The name of the DB subnet group.
                                                                                                                                                                                    	DBSubnetGroupName *string
                                                                                                                                                                                    
                                                                                                                                                                                    	// Provides the status of the DB subnet group.
                                                                                                                                                                                    	SubnetGroupStatus *string
                                                                                                                                                                                    
                                                                                                                                                                                    	// Contains a list of Subnet elements.
                                                                                                                                                                                    	Subnets []Subnet
                                                                                                                                                                                    
                                                                                                                                                                                    	// Provides the VpcId of the DB subnet group.
                                                                                                                                                                                    	VpcId *string
                                                                                                                                                                                    }

                                                                                                                                                                                      Contains the details of an Amazon RDS DB subnet group. This data type is used as a response element in the DescribeDBSubnetGroups action.

                                                                                                                                                                                      type DBSubnetGroupAlreadyExistsFault

                                                                                                                                                                                      type DBSubnetGroupAlreadyExistsFault struct {
                                                                                                                                                                                      	Message *string
                                                                                                                                                                                      }

                                                                                                                                                                                        DBSubnetGroupName is already used by an existing DB subnet group.

                                                                                                                                                                                        func (*DBSubnetGroupAlreadyExistsFault) Error

                                                                                                                                                                                        func (*DBSubnetGroupAlreadyExistsFault) ErrorCode

                                                                                                                                                                                        func (e *DBSubnetGroupAlreadyExistsFault) ErrorCode() string

                                                                                                                                                                                        func (*DBSubnetGroupAlreadyExistsFault) ErrorFault

                                                                                                                                                                                        func (*DBSubnetGroupAlreadyExistsFault) ErrorMessage

                                                                                                                                                                                        func (e *DBSubnetGroupAlreadyExistsFault) ErrorMessage() string

                                                                                                                                                                                        type DBSubnetGroupDoesNotCoverEnoughAZs

                                                                                                                                                                                        type DBSubnetGroupDoesNotCoverEnoughAZs struct {
                                                                                                                                                                                        	Message *string
                                                                                                                                                                                        }

                                                                                                                                                                                          Subnets in the DB subnet group should cover at least two Availability Zones unless there is only one Availability Zone.

                                                                                                                                                                                          func (*DBSubnetGroupDoesNotCoverEnoughAZs) Error

                                                                                                                                                                                          func (*DBSubnetGroupDoesNotCoverEnoughAZs) ErrorCode

                                                                                                                                                                                          func (*DBSubnetGroupDoesNotCoverEnoughAZs) ErrorFault

                                                                                                                                                                                          func (*DBSubnetGroupDoesNotCoverEnoughAZs) ErrorMessage

                                                                                                                                                                                          func (e *DBSubnetGroupDoesNotCoverEnoughAZs) ErrorMessage() string

                                                                                                                                                                                          type DBSubnetGroupNotAllowedFault

                                                                                                                                                                                          type DBSubnetGroupNotAllowedFault struct {
                                                                                                                                                                                          	Message *string
                                                                                                                                                                                          }

                                                                                                                                                                                            The DBSubnetGroup shouldn't be specified while creating read replicas that lie in the same region as the source instance.

                                                                                                                                                                                            func (*DBSubnetGroupNotAllowedFault) Error

                                                                                                                                                                                            func (*DBSubnetGroupNotAllowedFault) ErrorCode

                                                                                                                                                                                            func (e *DBSubnetGroupNotAllowedFault) ErrorCode() string

                                                                                                                                                                                            func (*DBSubnetGroupNotAllowedFault) ErrorFault

                                                                                                                                                                                            func (*DBSubnetGroupNotAllowedFault) ErrorMessage

                                                                                                                                                                                            func (e *DBSubnetGroupNotAllowedFault) ErrorMessage() string

                                                                                                                                                                                            type DBSubnetGroupNotFoundFault

                                                                                                                                                                                            type DBSubnetGroupNotFoundFault struct {
                                                                                                                                                                                            	Message *string
                                                                                                                                                                                            }

                                                                                                                                                                                              DBSubnetGroupName doesn't refer to an existing DB subnet group.

                                                                                                                                                                                              func (*DBSubnetGroupNotFoundFault) Error

                                                                                                                                                                                              func (*DBSubnetGroupNotFoundFault) ErrorCode

                                                                                                                                                                                              func (e *DBSubnetGroupNotFoundFault) ErrorCode() string

                                                                                                                                                                                              func (*DBSubnetGroupNotFoundFault) ErrorFault

                                                                                                                                                                                              func (*DBSubnetGroupNotFoundFault) ErrorMessage

                                                                                                                                                                                              func (e *DBSubnetGroupNotFoundFault) ErrorMessage() string

                                                                                                                                                                                              type DBSubnetGroupQuotaExceededFault

                                                                                                                                                                                              type DBSubnetGroupQuotaExceededFault struct {
                                                                                                                                                                                              	Message *string
                                                                                                                                                                                              }

                                                                                                                                                                                                The request would result in the user exceeding the allowed number of DB subnet groups.

                                                                                                                                                                                                func (*DBSubnetGroupQuotaExceededFault) Error

                                                                                                                                                                                                func (*DBSubnetGroupQuotaExceededFault) ErrorCode

                                                                                                                                                                                                func (e *DBSubnetGroupQuotaExceededFault) ErrorCode() string

                                                                                                                                                                                                func (*DBSubnetGroupQuotaExceededFault) ErrorFault

                                                                                                                                                                                                func (*DBSubnetGroupQuotaExceededFault) ErrorMessage

                                                                                                                                                                                                func (e *DBSubnetGroupQuotaExceededFault) ErrorMessage() string

                                                                                                                                                                                                type DBSubnetQuotaExceededFault

                                                                                                                                                                                                type DBSubnetQuotaExceededFault struct {
                                                                                                                                                                                                	Message *string
                                                                                                                                                                                                }

                                                                                                                                                                                                  The request would result in the user exceeding the allowed number of subnets in a DB subnet groups.

                                                                                                                                                                                                  func (*DBSubnetQuotaExceededFault) Error

                                                                                                                                                                                                  func (*DBSubnetQuotaExceededFault) ErrorCode

                                                                                                                                                                                                  func (e *DBSubnetQuotaExceededFault) ErrorCode() string

                                                                                                                                                                                                  func (*DBSubnetQuotaExceededFault) ErrorFault

                                                                                                                                                                                                  func (*DBSubnetQuotaExceededFault) ErrorMessage

                                                                                                                                                                                                  func (e *DBSubnetQuotaExceededFault) ErrorMessage() string

                                                                                                                                                                                                  type DBUpgradeDependencyFailureFault

                                                                                                                                                                                                  type DBUpgradeDependencyFailureFault struct {
                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                  }

                                                                                                                                                                                                    The DB upgrade failed because a resource the DB depends on can't be modified.

                                                                                                                                                                                                    func (*DBUpgradeDependencyFailureFault) Error

                                                                                                                                                                                                    func (*DBUpgradeDependencyFailureFault) ErrorCode

                                                                                                                                                                                                    func (e *DBUpgradeDependencyFailureFault) ErrorCode() string

                                                                                                                                                                                                    func (*DBUpgradeDependencyFailureFault) ErrorFault

                                                                                                                                                                                                    func (*DBUpgradeDependencyFailureFault) ErrorMessage

                                                                                                                                                                                                    func (e *DBUpgradeDependencyFailureFault) ErrorMessage() string

                                                                                                                                                                                                    type DescribeDBLogFilesDetails

                                                                                                                                                                                                    type DescribeDBLogFilesDetails struct {
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// A POSIX timestamp when the last log entry was written.
                                                                                                                                                                                                    	LastWritten int64
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// The name of the log file for the specified DB instance.
                                                                                                                                                                                                    	LogFileName *string
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// The size, in bytes, of the log file for the specified DB instance.
                                                                                                                                                                                                    	Size int64
                                                                                                                                                                                                    }

                                                                                                                                                                                                      This data type is used as a response element to DescribeDBLogFiles.

                                                                                                                                                                                                      type DomainMembership

                                                                                                                                                                                                      type DomainMembership struct {
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The identifier of the Active Directory Domain.
                                                                                                                                                                                                      	Domain *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The fully qualified domain name of the Active Directory Domain.
                                                                                                                                                                                                      	FQDN *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The name of the IAM role to be used when making API calls to the Directory
                                                                                                                                                                                                      	// Service.
                                                                                                                                                                                                      	IAMRoleName *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The status of the Active Directory Domain membership for the DB instance or
                                                                                                                                                                                                      	// cluster. Values include joined, pending-join, failed, and so on.
                                                                                                                                                                                                      	Status *string
                                                                                                                                                                                                      }

                                                                                                                                                                                                        An Active Directory Domain membership record associated with the DB instance or cluster.

                                                                                                                                                                                                        type DomainNotFoundFault

                                                                                                                                                                                                        type DomainNotFoundFault struct {
                                                                                                                                                                                                        	Message *string
                                                                                                                                                                                                        }

                                                                                                                                                                                                          Domain doesn't refer to an existing Active Directory domain.

                                                                                                                                                                                                          func (*DomainNotFoundFault) Error

                                                                                                                                                                                                          func (e *DomainNotFoundFault) Error() string

                                                                                                                                                                                                          func (*DomainNotFoundFault) ErrorCode

                                                                                                                                                                                                          func (e *DomainNotFoundFault) ErrorCode() string

                                                                                                                                                                                                          func (*DomainNotFoundFault) ErrorFault

                                                                                                                                                                                                          func (e *DomainNotFoundFault) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                          func (*DomainNotFoundFault) ErrorMessage

                                                                                                                                                                                                          func (e *DomainNotFoundFault) ErrorMessage() string

                                                                                                                                                                                                          type DoubleRange

                                                                                                                                                                                                          type DoubleRange struct {
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// The minimum value in the range.
                                                                                                                                                                                                          	From float64
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// The maximum value in the range.
                                                                                                                                                                                                          	To float64
                                                                                                                                                                                                          }

                                                                                                                                                                                                            A range of double values.

                                                                                                                                                                                                            type EC2SecurityGroup

                                                                                                                                                                                                            type EC2SecurityGroup struct {
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// Specifies the id of the EC2 security group.
                                                                                                                                                                                                            	EC2SecurityGroupId *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// Specifies the name of the EC2 security group.
                                                                                                                                                                                                            	EC2SecurityGroupName *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// Specifies the AWS ID of the owner of the EC2 security group specified in the
                                                                                                                                                                                                            	// EC2SecurityGroupName field.
                                                                                                                                                                                                            	EC2SecurityGroupOwnerId *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// Provides the status of the EC2 security group. Status can be "authorizing",
                                                                                                                                                                                                            	// "authorized", "revoking", and "revoked".
                                                                                                                                                                                                            	Status *string
                                                                                                                                                                                                            }

                                                                                                                                                                                                              This data type is used as a response element in the following actions:

                                                                                                                                                                                                              * AuthorizeDBSecurityGroupIngress

                                                                                                                                                                                                              * DescribeDBSecurityGroups

                                                                                                                                                                                                              * RevokeDBSecurityGroupIngress

                                                                                                                                                                                                              type Endpoint

                                                                                                                                                                                                              type Endpoint struct {
                                                                                                                                                                                                              
                                                                                                                                                                                                              	// Specifies the DNS address of the DB instance.
                                                                                                                                                                                                              	Address *string
                                                                                                                                                                                                              
                                                                                                                                                                                                              	// Specifies the ID that Amazon Route 53 assigns when you create a hosted zone.
                                                                                                                                                                                                              	HostedZoneId *string
                                                                                                                                                                                                              
                                                                                                                                                                                                              	// Specifies the port that the database engine is listening on.
                                                                                                                                                                                                              	Port int32
                                                                                                                                                                                                              }

                                                                                                                                                                                                                This data type represents the information you need to connect to an Amazon RDS DB instance. This data type is used as a response element in the following actions:

                                                                                                                                                                                                                * CreateDBInstance

                                                                                                                                                                                                                * DescribeDBInstances

                                                                                                                                                                                                                * DeleteDBInstance

                                                                                                                                                                                                                For the data structure that represents Amazon Aurora DB cluster endpoints, see DBClusterEndpoint.

                                                                                                                                                                                                                type EngineDefaults

                                                                                                                                                                                                                type EngineDefaults struct {
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// Specifies the name of the DB parameter group family that the engine default
                                                                                                                                                                                                                	// parameters apply to.
                                                                                                                                                                                                                	DBParameterGroupFamily *string
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// An optional pagination token provided by a previous EngineDefaults request. If
                                                                                                                                                                                                                	// this parameter is specified, the response includes only records beyond the
                                                                                                                                                                                                                	// marker, up to the value specified by MaxRecords .
                                                                                                                                                                                                                	Marker *string
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// Contains a list of engine default parameters.
                                                                                                                                                                                                                	Parameters []Parameter
                                                                                                                                                                                                                }

                                                                                                                                                                                                                  Contains the result of a successful invocation of the DescribeEngineDefaultParameters action.

                                                                                                                                                                                                                  type EngineFamily

                                                                                                                                                                                                                  type EngineFamily string
                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                  	EngineFamilyMysql      EngineFamily = "MYSQL"
                                                                                                                                                                                                                  	EngineFamilyPostgresql EngineFamily = "POSTGRESQL"
                                                                                                                                                                                                                  )

                                                                                                                                                                                                                    Enum values for EngineFamily

                                                                                                                                                                                                                    func (EngineFamily) Values

                                                                                                                                                                                                                    func (EngineFamily) Values() []EngineFamily

                                                                                                                                                                                                                      Values returns all known values for EngineFamily. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                      type Event

                                                                                                                                                                                                                      type Event struct {
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// Specifies the date and time of the event.
                                                                                                                                                                                                                      	Date *time.Time
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// Specifies the category for the event.
                                                                                                                                                                                                                      	EventCategories []string
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// Provides the text of this event.
                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The Amazon Resource Name (ARN) for the event.
                                                                                                                                                                                                                      	SourceArn *string
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// Provides the identifier for the source of the event.
                                                                                                                                                                                                                      	SourceIdentifier *string
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// Specifies the source type for this event.
                                                                                                                                                                                                                      	SourceType SourceType
                                                                                                                                                                                                                      }

                                                                                                                                                                                                                        This data type is used as a response element in the DescribeEvents action.

                                                                                                                                                                                                                        type EventCategoriesMap

                                                                                                                                                                                                                        type EventCategoriesMap struct {
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// The event categories for the specified source type
                                                                                                                                                                                                                        	EventCategories []string
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// The source type that the returned categories belong to
                                                                                                                                                                                                                        	SourceType *string
                                                                                                                                                                                                                        }

                                                                                                                                                                                                                          Contains the results of a successful invocation of the DescribeEventCategories operation.

                                                                                                                                                                                                                          type EventSubscription

                                                                                                                                                                                                                          type EventSubscription struct {
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// The RDS event notification subscription Id.
                                                                                                                                                                                                                          	CustSubscriptionId *string
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// The AWS customer account associated with the RDS event notification
                                                                                                                                                                                                                          	// subscription.
                                                                                                                                                                                                                          	CustomerAwsId *string
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// A Boolean value indicating if the subscription is enabled. True indicates the
                                                                                                                                                                                                                          	// subscription is enabled.
                                                                                                                                                                                                                          	Enabled bool
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// A list of event categories for the RDS event notification subscription.
                                                                                                                                                                                                                          	EventCategoriesList []string
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// The Amazon Resource Name (ARN) for the event subscription.
                                                                                                                                                                                                                          	EventSubscriptionArn *string
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// The topic ARN of the RDS event notification subscription.
                                                                                                                                                                                                                          	SnsTopicArn *string
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// A list of source IDs for the RDS event notification subscription.
                                                                                                                                                                                                                          	SourceIdsList []string
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// The source type for the RDS event notification subscription.
                                                                                                                                                                                                                          	SourceType *string
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// The status of the RDS event notification subscription. Constraints: Can be one
                                                                                                                                                                                                                          	// of the following: creating | modifying | deleting | active | no-permission |
                                                                                                                                                                                                                          	// topic-not-exist The status "no-permission" indicates that RDS no longer has
                                                                                                                                                                                                                          	// permission to post to the SNS topic. The status "topic-not-exist" indicates that
                                                                                                                                                                                                                          	// the topic was deleted after the subscription was created.
                                                                                                                                                                                                                          	Status *string
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// The time the RDS event notification subscription was created.
                                                                                                                                                                                                                          	SubscriptionCreationTime *string
                                                                                                                                                                                                                          }

                                                                                                                                                                                                                            Contains the results of a successful invocation of the DescribeEventSubscriptions action.

                                                                                                                                                                                                                            type EventSubscriptionQuotaExceededFault

                                                                                                                                                                                                                            type EventSubscriptionQuotaExceededFault struct {
                                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                                            }

                                                                                                                                                                                                                              You have reached the maximum number of event subscriptions.

                                                                                                                                                                                                                              func (*EventSubscriptionQuotaExceededFault) Error

                                                                                                                                                                                                                              func (*EventSubscriptionQuotaExceededFault) ErrorCode

                                                                                                                                                                                                                              func (*EventSubscriptionQuotaExceededFault) ErrorFault

                                                                                                                                                                                                                              func (*EventSubscriptionQuotaExceededFault) ErrorMessage

                                                                                                                                                                                                                              func (e *EventSubscriptionQuotaExceededFault) ErrorMessage() string

                                                                                                                                                                                                                              type ExportTask

                                                                                                                                                                                                                              type ExportTask struct {
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// 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 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 name of the IAM role that is used to write to Amazon S3 when exporting a
                                                                                                                                                                                                                              	// snapshot.
                                                                                                                                                                                                                              	IamRoleArn *string
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The key identifier of the AWS KMS customer master key (CMK) that is used to
                                                                                                                                                                                                                              	// encrypt the snapshot when it's exported to Amazon S3. The AWS KMS CMK identifier
                                                                                                                                                                                                                              	// is its key ARN, key ID, alias ARN, or alias name. The IAM role used for the
                                                                                                                                                                                                                              	// snapshot export must have encryption and decryption permissions to use this AWS
                                                                                                                                                                                                                              	// KMS CMK.
                                                                                                                                                                                                                              	KmsKeyId *string
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The progress of the snapshot export task as a percentage.
                                                                                                                                                                                                                              	PercentProgress int32
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The Amazon S3 bucket that the snapshot is exported to.
                                                                                                                                                                                                                              	S3Bucket *string
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The Amazon S3 bucket prefix that is the file name and path of the exported
                                                                                                                                                                                                                              	// snapshot.
                                                                                                                                                                                                                              	S3Prefix *string
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The time that the snapshot was created.
                                                                                                                                                                                                                              	SnapshotTime *time.Time
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The Amazon Resource Name (ARN) of the snapshot exported to Amazon S3.
                                                                                                                                                                                                                              	SourceArn *string
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The progress status of the export task.
                                                                                                                                                                                                                              	Status *string
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The time that the snapshot export task completed.
                                                                                                                                                                                                                              	TaskEndTime *time.Time
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The time that the snapshot export task started.
                                                                                                                                                                                                                              	TaskStartTime *time.Time
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The total amount of data exported, in gigabytes.
                                                                                                                                                                                                                              	TotalExtractedDataInGB int32
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// A warning about the snapshot export task.
                                                                                                                                                                                                                              	WarningMessage *string
                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                Contains the details of a snapshot export to Amazon S3. This data type is used as a response element in the DescribeExportTasks action.

                                                                                                                                                                                                                                type ExportTaskAlreadyExistsFault

                                                                                                                                                                                                                                type ExportTaskAlreadyExistsFault struct {
                                                                                                                                                                                                                                	Message *string
                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                  You can't start an export task that's already running.

                                                                                                                                                                                                                                  func (*ExportTaskAlreadyExistsFault) Error

                                                                                                                                                                                                                                  func (*ExportTaskAlreadyExistsFault) ErrorCode

                                                                                                                                                                                                                                  func (e *ExportTaskAlreadyExistsFault) ErrorCode() string

                                                                                                                                                                                                                                  func (*ExportTaskAlreadyExistsFault) ErrorFault

                                                                                                                                                                                                                                  func (*ExportTaskAlreadyExistsFault) ErrorMessage

                                                                                                                                                                                                                                  func (e *ExportTaskAlreadyExistsFault) ErrorMessage() string

                                                                                                                                                                                                                                  type ExportTaskNotFoundFault

                                                                                                                                                                                                                                  type ExportTaskNotFoundFault struct {
                                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                    The export task doesn't exist.

                                                                                                                                                                                                                                    func (*ExportTaskNotFoundFault) Error

                                                                                                                                                                                                                                    func (e *ExportTaskNotFoundFault) Error() string

                                                                                                                                                                                                                                    func (*ExportTaskNotFoundFault) ErrorCode

                                                                                                                                                                                                                                    func (e *ExportTaskNotFoundFault) ErrorCode() string

                                                                                                                                                                                                                                    func (*ExportTaskNotFoundFault) ErrorFault

                                                                                                                                                                                                                                    func (e *ExportTaskNotFoundFault) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                    func (*ExportTaskNotFoundFault) ErrorMessage

                                                                                                                                                                                                                                    func (e *ExportTaskNotFoundFault) ErrorMessage() string

                                                                                                                                                                                                                                    type Filter

                                                                                                                                                                                                                                    type Filter struct {
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// The name of the filter. Filter names are case-sensitive.
                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                    	Name *string
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// One or more filter values. Filter values are case-sensitive.
                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                    	Values []string
                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                      A filter name and value pair that is used to return a more specific list of results from a describe operation. Filters can be used to match a set of resources by specific criteria, such as IDs. The filters supported by a describe operation are documented with the describe operation. Currently, wildcards are not supported in filters. The following actions can be filtered:

                                                                                                                                                                                                                                      * DescribeDBClusterBacktracks

                                                                                                                                                                                                                                      * DescribeDBClusterEndpoints

                                                                                                                                                                                                                                      * DescribeDBClusters

                                                                                                                                                                                                                                      * DescribeDBInstances

                                                                                                                                                                                                                                      * DescribePendingMaintenanceActions

                                                                                                                                                                                                                                      type GlobalCluster

                                                                                                                                                                                                                                      type GlobalCluster struct {
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The default database name within the new global database cluster.
                                                                                                                                                                                                                                      	DatabaseName *string
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The deletion protection setting for the new global database cluster.
                                                                                                                                                                                                                                      	DeletionProtection *bool
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The Aurora database engine used by the global database cluster.
                                                                                                                                                                                                                                      	Engine *string
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// Indicates the database engine version.
                                                                                                                                                                                                                                      	EngineVersion *string
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The Amazon Resource Name (ARN) for the global database cluster.
                                                                                                                                                                                                                                      	GlobalClusterArn *string
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// Contains a user-supplied global database cluster identifier. This identifier is
                                                                                                                                                                                                                                      	// the unique key that identifies a global database cluster.
                                                                                                                                                                                                                                      	GlobalClusterIdentifier *string
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The list of cluster IDs for secondary clusters within the global database
                                                                                                                                                                                                                                      	// cluster. Currently limited to 1 item.
                                                                                                                                                                                                                                      	GlobalClusterMembers []GlobalClusterMember
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The AWS Region-unique, immutable identifier for the global database cluster.
                                                                                                                                                                                                                                      	// This identifier is found in AWS CloudTrail log entries whenever the AWS KMS
                                                                                                                                                                                                                                      	// customer master key (CMK) for the DB cluster is accessed.
                                                                                                                                                                                                                                      	GlobalClusterResourceId *string
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// Specifies the current state of this global database cluster.
                                                                                                                                                                                                                                      	Status *string
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The storage encryption setting for the global database cluster.
                                                                                                                                                                                                                                      	StorageEncrypted *bool
                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                        A data type representing an Aurora global database.

                                                                                                                                                                                                                                        type GlobalClusterAlreadyExistsFault

                                                                                                                                                                                                                                        type GlobalClusterAlreadyExistsFault struct {
                                                                                                                                                                                                                                        	Message *string
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                          The GlobalClusterIdentifier already exists. Choose a new global database identifier (unique name) to create a new global database cluster.

                                                                                                                                                                                                                                          func (*GlobalClusterAlreadyExistsFault) Error

                                                                                                                                                                                                                                          func (*GlobalClusterAlreadyExistsFault) ErrorCode

                                                                                                                                                                                                                                          func (e *GlobalClusterAlreadyExistsFault) ErrorCode() string

                                                                                                                                                                                                                                          func (*GlobalClusterAlreadyExistsFault) ErrorFault

                                                                                                                                                                                                                                          func (*GlobalClusterAlreadyExistsFault) ErrorMessage

                                                                                                                                                                                                                                          func (e *GlobalClusterAlreadyExistsFault) ErrorMessage() string

                                                                                                                                                                                                                                          type GlobalClusterMember

                                                                                                                                                                                                                                          type GlobalClusterMember struct {
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// The Amazon Resource Name (ARN) for each Aurora cluster.
                                                                                                                                                                                                                                          	DBClusterArn *string
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// Specifies whether a secondary cluster in an Aurora global database has write
                                                                                                                                                                                                                                          	// forwarding enabled, not enabled, or is in the process of enabling it.
                                                                                                                                                                                                                                          	GlobalWriteForwardingStatus WriteForwardingStatus
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// Specifies whether the Aurora cluster is the primary cluster (that is, has
                                                                                                                                                                                                                                          	// read-write capability) for the Aurora global database with which it is
                                                                                                                                                                                                                                          	// associated.
                                                                                                                                                                                                                                          	IsWriter bool
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// The Amazon Resource Name (ARN) for each read-only secondary cluster associated
                                                                                                                                                                                                                                          	// with the Aurora global database.
                                                                                                                                                                                                                                          	Readers []string
                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                            A data structure with information about any primary and secondary clusters associated with an Aurora global database.

                                                                                                                                                                                                                                            type GlobalClusterNotFoundFault

                                                                                                                                                                                                                                            type GlobalClusterNotFoundFault struct {
                                                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                              The GlobalClusterIdentifier doesn't refer to an existing global database cluster.

                                                                                                                                                                                                                                              func (*GlobalClusterNotFoundFault) Error

                                                                                                                                                                                                                                              func (*GlobalClusterNotFoundFault) ErrorCode

                                                                                                                                                                                                                                              func (e *GlobalClusterNotFoundFault) ErrorCode() string

                                                                                                                                                                                                                                              func (*GlobalClusterNotFoundFault) ErrorFault

                                                                                                                                                                                                                                              func (*GlobalClusterNotFoundFault) ErrorMessage

                                                                                                                                                                                                                                              func (e *GlobalClusterNotFoundFault) ErrorMessage() string

                                                                                                                                                                                                                                              type GlobalClusterQuotaExceededFault

                                                                                                                                                                                                                                              type GlobalClusterQuotaExceededFault struct {
                                                                                                                                                                                                                                              	Message *string
                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                The number of global database clusters for this account is already at the maximum allowed.

                                                                                                                                                                                                                                                func (*GlobalClusterQuotaExceededFault) Error

                                                                                                                                                                                                                                                func (*GlobalClusterQuotaExceededFault) ErrorCode

                                                                                                                                                                                                                                                func (e *GlobalClusterQuotaExceededFault) ErrorCode() string

                                                                                                                                                                                                                                                func (*GlobalClusterQuotaExceededFault) ErrorFault

                                                                                                                                                                                                                                                func (*GlobalClusterQuotaExceededFault) ErrorMessage

                                                                                                                                                                                                                                                func (e *GlobalClusterQuotaExceededFault) ErrorMessage() string

                                                                                                                                                                                                                                                type IAMAuthMode

                                                                                                                                                                                                                                                type IAMAuthMode string
                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                	IAMAuthModeDisabled IAMAuthMode = "DISABLED"
                                                                                                                                                                                                                                                	IAMAuthModeRequired IAMAuthMode = "REQUIRED"
                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                  Enum values for IAMAuthMode

                                                                                                                                                                                                                                                  func (IAMAuthMode) Values

                                                                                                                                                                                                                                                  func (IAMAuthMode) Values() []IAMAuthMode

                                                                                                                                                                                                                                                    Values returns all known values for IAMAuthMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                    type IPRange

                                                                                                                                                                                                                                                    type IPRange struct {
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    	// Specifies the IP range.
                                                                                                                                                                                                                                                    	CIDRIP *string
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    	// Specifies the status of the IP range. Status can be "authorizing", "authorized",
                                                                                                                                                                                                                                                    	// "revoking", and "revoked".
                                                                                                                                                                                                                                                    	Status *string
                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                      This data type is used as a response element in the DescribeDBSecurityGroups action.

                                                                                                                                                                                                                                                      type IamRoleMissingPermissionsFault

                                                                                                                                                                                                                                                      type IamRoleMissingPermissionsFault struct {
                                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                        The IAM role requires additional permissions to export to an Amazon S3 bucket.

                                                                                                                                                                                                                                                        func (*IamRoleMissingPermissionsFault) Error

                                                                                                                                                                                                                                                        func (*IamRoleMissingPermissionsFault) ErrorCode

                                                                                                                                                                                                                                                        func (e *IamRoleMissingPermissionsFault) ErrorCode() string

                                                                                                                                                                                                                                                        func (*IamRoleMissingPermissionsFault) ErrorFault

                                                                                                                                                                                                                                                        func (*IamRoleMissingPermissionsFault) ErrorMessage

                                                                                                                                                                                                                                                        func (e *IamRoleMissingPermissionsFault) ErrorMessage() string

                                                                                                                                                                                                                                                        type IamRoleNotFoundFault

                                                                                                                                                                                                                                                        type IamRoleNotFoundFault struct {
                                                                                                                                                                                                                                                        	Message *string
                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                          The IAM role is missing for exporting to an Amazon S3 bucket.

                                                                                                                                                                                                                                                          func (*IamRoleNotFoundFault) Error

                                                                                                                                                                                                                                                          func (e *IamRoleNotFoundFault) Error() string

                                                                                                                                                                                                                                                          func (*IamRoleNotFoundFault) ErrorCode

                                                                                                                                                                                                                                                          func (e *IamRoleNotFoundFault) ErrorCode() string

                                                                                                                                                                                                                                                          func (*IamRoleNotFoundFault) ErrorFault

                                                                                                                                                                                                                                                          func (e *IamRoleNotFoundFault) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                          func (*IamRoleNotFoundFault) ErrorMessage

                                                                                                                                                                                                                                                          func (e *IamRoleNotFoundFault) ErrorMessage() string

                                                                                                                                                                                                                                                          type InstallationMedia

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

                                                                                                                                                                                                                                                            Contains the installation media for a DB engine that requires an on-premises customer provided license, such as Microsoft SQL Server.

                                                                                                                                                                                                                                                            type InstallationMediaAlreadyExistsFault

                                                                                                                                                                                                                                                            type InstallationMediaAlreadyExistsFault struct {
                                                                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                              The specified installation medium has already been imported.

                                                                                                                                                                                                                                                              func (*InstallationMediaAlreadyExistsFault) Error

                                                                                                                                                                                                                                                              func (*InstallationMediaAlreadyExistsFault) ErrorCode

                                                                                                                                                                                                                                                              func (*InstallationMediaAlreadyExistsFault) ErrorFault

                                                                                                                                                                                                                                                              func (*InstallationMediaAlreadyExistsFault) ErrorMessage

                                                                                                                                                                                                                                                              func (e *InstallationMediaAlreadyExistsFault) ErrorMessage() string

                                                                                                                                                                                                                                                              type InstallationMediaFailureCause

                                                                                                                                                                                                                                                              type InstallationMediaFailureCause struct {
                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                              	// The reason that an installation media import failed.
                                                                                                                                                                                                                                                              	Message *string
                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                Contains the cause of an installation media failure. Installation media is used for a DB engine that requires an on-premises customer provided license, such as Microsoft SQL Server.

                                                                                                                                                                                                                                                                type InstallationMediaNotFoundFault

                                                                                                                                                                                                                                                                type InstallationMediaNotFoundFault struct {
                                                                                                                                                                                                                                                                	Message *string
                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                  InstallationMediaID doesn't refer to an existing installation medium.

                                                                                                                                                                                                                                                                  func (*InstallationMediaNotFoundFault) Error

                                                                                                                                                                                                                                                                  func (*InstallationMediaNotFoundFault) ErrorCode

                                                                                                                                                                                                                                                                  func (e *InstallationMediaNotFoundFault) ErrorCode() string

                                                                                                                                                                                                                                                                  func (*InstallationMediaNotFoundFault) ErrorFault

                                                                                                                                                                                                                                                                  func (*InstallationMediaNotFoundFault) ErrorMessage

                                                                                                                                                                                                                                                                  func (e *InstallationMediaNotFoundFault) ErrorMessage() string

                                                                                                                                                                                                                                                                  type InstanceQuotaExceededFault

                                                                                                                                                                                                                                                                  type InstanceQuotaExceededFault struct {
                                                                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                    The request would result in the user exceeding the allowed number of DB instances.

                                                                                                                                                                                                                                                                    func (*InstanceQuotaExceededFault) Error

                                                                                                                                                                                                                                                                    func (*InstanceQuotaExceededFault) ErrorCode

                                                                                                                                                                                                                                                                    func (e *InstanceQuotaExceededFault) ErrorCode() string

                                                                                                                                                                                                                                                                    func (*InstanceQuotaExceededFault) ErrorFault

                                                                                                                                                                                                                                                                    func (*InstanceQuotaExceededFault) ErrorMessage

                                                                                                                                                                                                                                                                    func (e *InstanceQuotaExceededFault) ErrorMessage() string

                                                                                                                                                                                                                                                                    type InsufficientAvailableIPsInSubnetFault

                                                                                                                                                                                                                                                                    type InsufficientAvailableIPsInSubnetFault struct {
                                                                                                                                                                                                                                                                    	Message *string
                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                      The requested operation can't be performed because there aren't enough available IP addresses in the proxy's subnets. Add more CIDR blocks to the VPC or remove IP address that aren't required from the subnets.

                                                                                                                                                                                                                                                                      func (*InsufficientAvailableIPsInSubnetFault) Error

                                                                                                                                                                                                                                                                      func (*InsufficientAvailableIPsInSubnetFault) ErrorCode

                                                                                                                                                                                                                                                                      func (*InsufficientAvailableIPsInSubnetFault) ErrorFault

                                                                                                                                                                                                                                                                      func (*InsufficientAvailableIPsInSubnetFault) ErrorMessage

                                                                                                                                                                                                                                                                      type InsufficientDBClusterCapacityFault

                                                                                                                                                                                                                                                                      type InsufficientDBClusterCapacityFault struct {
                                                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                        The DB cluster doesn't have enough capacity for the current operation.

                                                                                                                                                                                                                                                                        func (*InsufficientDBClusterCapacityFault) Error

                                                                                                                                                                                                                                                                        func (*InsufficientDBClusterCapacityFault) ErrorCode

                                                                                                                                                                                                                                                                        func (*InsufficientDBClusterCapacityFault) ErrorFault

                                                                                                                                                                                                                                                                        func (*InsufficientDBClusterCapacityFault) ErrorMessage

                                                                                                                                                                                                                                                                        func (e *InsufficientDBClusterCapacityFault) ErrorMessage() string

                                                                                                                                                                                                                                                                        type InsufficientDBInstanceCapacityFault

                                                                                                                                                                                                                                                                        type InsufficientDBInstanceCapacityFault struct {
                                                                                                                                                                                                                                                                        	Message *string
                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                          The specified DB instance class isn't available in the specified Availability Zone.

                                                                                                                                                                                                                                                                          func (*InsufficientDBInstanceCapacityFault) Error

                                                                                                                                                                                                                                                                          func (*InsufficientDBInstanceCapacityFault) ErrorCode

                                                                                                                                                                                                                                                                          func (*InsufficientDBInstanceCapacityFault) ErrorFault

                                                                                                                                                                                                                                                                          func (*InsufficientDBInstanceCapacityFault) ErrorMessage

                                                                                                                                                                                                                                                                          func (e *InsufficientDBInstanceCapacityFault) ErrorMessage() string

                                                                                                                                                                                                                                                                          type InsufficientStorageClusterCapacityFault

                                                                                                                                                                                                                                                                          type InsufficientStorageClusterCapacityFault struct {
                                                                                                                                                                                                                                                                          	Message *string
                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                            There is insufficient storage available for the current action. You might be able to resolve this error by updating your subnet group to use different Availability Zones that have more storage available.

                                                                                                                                                                                                                                                                            func (*InsufficientStorageClusterCapacityFault) Error

                                                                                                                                                                                                                                                                            func (*InsufficientStorageClusterCapacityFault) ErrorCode

                                                                                                                                                                                                                                                                            func (*InsufficientStorageClusterCapacityFault) ErrorFault

                                                                                                                                                                                                                                                                            func (*InsufficientStorageClusterCapacityFault) ErrorMessage

                                                                                                                                                                                                                                                                            type InvalidDBClusterCapacityFault

                                                                                                                                                                                                                                                                            type InvalidDBClusterCapacityFault struct {
                                                                                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                              Capacity isn't a valid Aurora Serverless DB cluster capacity. Valid capacity values are 2, 4, 8, 16, 32, 64, 128, and 256.

                                                                                                                                                                                                                                                                              func (*InvalidDBClusterCapacityFault) Error

                                                                                                                                                                                                                                                                              func (*InvalidDBClusterCapacityFault) ErrorCode

                                                                                                                                                                                                                                                                              func (e *InvalidDBClusterCapacityFault) ErrorCode() string

                                                                                                                                                                                                                                                                              func (*InvalidDBClusterCapacityFault) ErrorFault

                                                                                                                                                                                                                                                                              func (*InvalidDBClusterCapacityFault) ErrorMessage

                                                                                                                                                                                                                                                                              func (e *InvalidDBClusterCapacityFault) ErrorMessage() string

                                                                                                                                                                                                                                                                              type InvalidDBClusterEndpointStateFault

                                                                                                                                                                                                                                                                              type InvalidDBClusterEndpointStateFault struct {
                                                                                                                                                                                                                                                                              	Message *string
                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                The requested operation can't be performed on the endpoint while the endpoint is in this state.

                                                                                                                                                                                                                                                                                func (*InvalidDBClusterEndpointStateFault) Error

                                                                                                                                                                                                                                                                                func (*InvalidDBClusterEndpointStateFault) ErrorCode

                                                                                                                                                                                                                                                                                func (*InvalidDBClusterEndpointStateFault) ErrorFault

                                                                                                                                                                                                                                                                                func (*InvalidDBClusterEndpointStateFault) ErrorMessage

                                                                                                                                                                                                                                                                                func (e *InvalidDBClusterEndpointStateFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                type InvalidDBClusterSnapshotStateFault

                                                                                                                                                                                                                                                                                type InvalidDBClusterSnapshotStateFault struct {
                                                                                                                                                                                                                                                                                	Message *string
                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                  The supplied value isn't a valid DB cluster snapshot state.

                                                                                                                                                                                                                                                                                  func (*InvalidDBClusterSnapshotStateFault) Error

                                                                                                                                                                                                                                                                                  func (*InvalidDBClusterSnapshotStateFault) ErrorCode

                                                                                                                                                                                                                                                                                  func (*InvalidDBClusterSnapshotStateFault) ErrorFault

                                                                                                                                                                                                                                                                                  func (*InvalidDBClusterSnapshotStateFault) ErrorMessage

                                                                                                                                                                                                                                                                                  func (e *InvalidDBClusterSnapshotStateFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                  type InvalidDBClusterStateFault

                                                                                                                                                                                                                                                                                  type InvalidDBClusterStateFault struct {
                                                                                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                    The requested operation can't be performed while the cluster is in this state.

                                                                                                                                                                                                                                                                                    func (*InvalidDBClusterStateFault) Error

                                                                                                                                                                                                                                                                                    func (*InvalidDBClusterStateFault) ErrorCode

                                                                                                                                                                                                                                                                                    func (e *InvalidDBClusterStateFault) ErrorCode() string

                                                                                                                                                                                                                                                                                    func (*InvalidDBClusterStateFault) ErrorFault

                                                                                                                                                                                                                                                                                    func (*InvalidDBClusterStateFault) ErrorMessage

                                                                                                                                                                                                                                                                                    func (e *InvalidDBClusterStateFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                    type InvalidDBInstanceAutomatedBackupStateFault

                                                                                                                                                                                                                                                                                    type InvalidDBInstanceAutomatedBackupStateFault struct {
                                                                                                                                                                                                                                                                                    	Message *string
                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                      The automated backup is in an invalid state. For example, this automated backup is associated with an active instance.

                                                                                                                                                                                                                                                                                      func (*InvalidDBInstanceAutomatedBackupStateFault) Error

                                                                                                                                                                                                                                                                                      func (*InvalidDBInstanceAutomatedBackupStateFault) ErrorCode

                                                                                                                                                                                                                                                                                      func (*InvalidDBInstanceAutomatedBackupStateFault) ErrorFault

                                                                                                                                                                                                                                                                                      func (*InvalidDBInstanceAutomatedBackupStateFault) ErrorMessage

                                                                                                                                                                                                                                                                                      type InvalidDBInstanceStateFault

                                                                                                                                                                                                                                                                                      type InvalidDBInstanceStateFault struct {
                                                                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                        The DB instance isn't in a valid state.

                                                                                                                                                                                                                                                                                        func (*InvalidDBInstanceStateFault) Error

                                                                                                                                                                                                                                                                                        func (*InvalidDBInstanceStateFault) ErrorCode

                                                                                                                                                                                                                                                                                        func (e *InvalidDBInstanceStateFault) ErrorCode() string

                                                                                                                                                                                                                                                                                        func (*InvalidDBInstanceStateFault) ErrorFault

                                                                                                                                                                                                                                                                                        func (*InvalidDBInstanceStateFault) ErrorMessage

                                                                                                                                                                                                                                                                                        func (e *InvalidDBInstanceStateFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                        type InvalidDBParameterGroupStateFault

                                                                                                                                                                                                                                                                                        type InvalidDBParameterGroupStateFault struct {
                                                                                                                                                                                                                                                                                        	Message *string
                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                          The DB parameter group is in use or is in an invalid state. If you are attempting to delete the parameter group, you can't delete it when the parameter group is in this state.

                                                                                                                                                                                                                                                                                          func (*InvalidDBParameterGroupStateFault) Error

                                                                                                                                                                                                                                                                                          func (*InvalidDBParameterGroupStateFault) ErrorCode

                                                                                                                                                                                                                                                                                          func (*InvalidDBParameterGroupStateFault) ErrorFault

                                                                                                                                                                                                                                                                                          func (*InvalidDBParameterGroupStateFault) ErrorMessage

                                                                                                                                                                                                                                                                                          func (e *InvalidDBParameterGroupStateFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                          type InvalidDBProxyStateFault

                                                                                                                                                                                                                                                                                          type InvalidDBProxyStateFault struct {
                                                                                                                                                                                                                                                                                          	Message *string
                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                            The requested operation can't be performed while the proxy is in this state.

                                                                                                                                                                                                                                                                                            func (*InvalidDBProxyStateFault) Error

                                                                                                                                                                                                                                                                                            func (e *InvalidDBProxyStateFault) Error() string

                                                                                                                                                                                                                                                                                            func (*InvalidDBProxyStateFault) ErrorCode

                                                                                                                                                                                                                                                                                            func (e *InvalidDBProxyStateFault) ErrorCode() string

                                                                                                                                                                                                                                                                                            func (*InvalidDBProxyStateFault) ErrorFault

                                                                                                                                                                                                                                                                                            func (e *InvalidDBProxyStateFault) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                            func (*InvalidDBProxyStateFault) ErrorMessage

                                                                                                                                                                                                                                                                                            func (e *InvalidDBProxyStateFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                            type InvalidDBSecurityGroupStateFault

                                                                                                                                                                                                                                                                                            type InvalidDBSecurityGroupStateFault struct {
                                                                                                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                              The state of the DB security group doesn't allow deletion.

                                                                                                                                                                                                                                                                                              func (*InvalidDBSecurityGroupStateFault) Error

                                                                                                                                                                                                                                                                                              func (*InvalidDBSecurityGroupStateFault) ErrorCode

                                                                                                                                                                                                                                                                                              func (*InvalidDBSecurityGroupStateFault) ErrorFault

                                                                                                                                                                                                                                                                                              func (*InvalidDBSecurityGroupStateFault) ErrorMessage

                                                                                                                                                                                                                                                                                              func (e *InvalidDBSecurityGroupStateFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                              type InvalidDBSnapshotStateFault

                                                                                                                                                                                                                                                                                              type InvalidDBSnapshotStateFault struct {
                                                                                                                                                                                                                                                                                              	Message *string
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                The state of the DB snapshot doesn't allow deletion.

                                                                                                                                                                                                                                                                                                func (*InvalidDBSnapshotStateFault) Error

                                                                                                                                                                                                                                                                                                func (*InvalidDBSnapshotStateFault) ErrorCode

                                                                                                                                                                                                                                                                                                func (e *InvalidDBSnapshotStateFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                func (*InvalidDBSnapshotStateFault) ErrorFault

                                                                                                                                                                                                                                                                                                func (*InvalidDBSnapshotStateFault) ErrorMessage

                                                                                                                                                                                                                                                                                                func (e *InvalidDBSnapshotStateFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                type InvalidDBSubnetGroupFault

                                                                                                                                                                                                                                                                                                type InvalidDBSubnetGroupFault struct {
                                                                                                                                                                                                                                                                                                	Message *string
                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                  The DBSubnetGroup doesn't belong to the same VPC as that of an existing cross-region read replica of the same source instance.

                                                                                                                                                                                                                                                                                                  func (*InvalidDBSubnetGroupFault) Error

                                                                                                                                                                                                                                                                                                  func (e *InvalidDBSubnetGroupFault) Error() string

                                                                                                                                                                                                                                                                                                  func (*InvalidDBSubnetGroupFault) ErrorCode

                                                                                                                                                                                                                                                                                                  func (e *InvalidDBSubnetGroupFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                  func (*InvalidDBSubnetGroupFault) ErrorFault

                                                                                                                                                                                                                                                                                                  func (*InvalidDBSubnetGroupFault) ErrorMessage

                                                                                                                                                                                                                                                                                                  func (e *InvalidDBSubnetGroupFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                  type InvalidDBSubnetGroupStateFault

                                                                                                                                                                                                                                                                                                  type InvalidDBSubnetGroupStateFault struct {
                                                                                                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                    The DB subnet group cannot be deleted because it's in use.

                                                                                                                                                                                                                                                                                                    func (*InvalidDBSubnetGroupStateFault) Error

                                                                                                                                                                                                                                                                                                    func (*InvalidDBSubnetGroupStateFault) ErrorCode

                                                                                                                                                                                                                                                                                                    func (e *InvalidDBSubnetGroupStateFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                    func (*InvalidDBSubnetGroupStateFault) ErrorFault

                                                                                                                                                                                                                                                                                                    func (*InvalidDBSubnetGroupStateFault) ErrorMessage

                                                                                                                                                                                                                                                                                                    func (e *InvalidDBSubnetGroupStateFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                    type InvalidDBSubnetStateFault

                                                                                                                                                                                                                                                                                                    type InvalidDBSubnetStateFault struct {
                                                                                                                                                                                                                                                                                                    	Message *string
                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                      The DB subnet isn't in the available state.

                                                                                                                                                                                                                                                                                                      func (*InvalidDBSubnetStateFault) Error

                                                                                                                                                                                                                                                                                                      func (e *InvalidDBSubnetStateFault) Error() string

                                                                                                                                                                                                                                                                                                      func (*InvalidDBSubnetStateFault) ErrorCode

                                                                                                                                                                                                                                                                                                      func (e *InvalidDBSubnetStateFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                      func (*InvalidDBSubnetStateFault) ErrorFault

                                                                                                                                                                                                                                                                                                      func (*InvalidDBSubnetStateFault) ErrorMessage

                                                                                                                                                                                                                                                                                                      func (e *InvalidDBSubnetStateFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                      type InvalidEventSubscriptionStateFault

                                                                                                                                                                                                                                                                                                      type InvalidEventSubscriptionStateFault struct {
                                                                                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                        This error can occur if someone else is modifying a subscription. You should retry the action.

                                                                                                                                                                                                                                                                                                        func (*InvalidEventSubscriptionStateFault) Error

                                                                                                                                                                                                                                                                                                        func (*InvalidEventSubscriptionStateFault) ErrorCode

                                                                                                                                                                                                                                                                                                        func (*InvalidEventSubscriptionStateFault) ErrorFault

                                                                                                                                                                                                                                                                                                        func (*InvalidEventSubscriptionStateFault) ErrorMessage

                                                                                                                                                                                                                                                                                                        func (e *InvalidEventSubscriptionStateFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                        type InvalidExportOnlyFault

                                                                                                                                                                                                                                                                                                        type InvalidExportOnlyFault struct {
                                                                                                                                                                                                                                                                                                        	Message *string
                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                          The export is invalid for exporting to an Amazon S3 bucket.

                                                                                                                                                                                                                                                                                                          func (*InvalidExportOnlyFault) Error

                                                                                                                                                                                                                                                                                                          func (e *InvalidExportOnlyFault) Error() string

                                                                                                                                                                                                                                                                                                          func (*InvalidExportOnlyFault) ErrorCode

                                                                                                                                                                                                                                                                                                          func (e *InvalidExportOnlyFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                          func (*InvalidExportOnlyFault) ErrorFault

                                                                                                                                                                                                                                                                                                          func (e *InvalidExportOnlyFault) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                                          func (*InvalidExportOnlyFault) ErrorMessage

                                                                                                                                                                                                                                                                                                          func (e *InvalidExportOnlyFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                          type InvalidExportSourceStateFault

                                                                                                                                                                                                                                                                                                          type InvalidExportSourceStateFault struct {
                                                                                                                                                                                                                                                                                                          	Message *string
                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                            The state of the export snapshot is invalid for exporting to an Amazon S3 bucket.

                                                                                                                                                                                                                                                                                                            func (*InvalidExportSourceStateFault) Error

                                                                                                                                                                                                                                                                                                            func (*InvalidExportSourceStateFault) ErrorCode

                                                                                                                                                                                                                                                                                                            func (e *InvalidExportSourceStateFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                            func (*InvalidExportSourceStateFault) ErrorFault

                                                                                                                                                                                                                                                                                                            func (*InvalidExportSourceStateFault) ErrorMessage

                                                                                                                                                                                                                                                                                                            func (e *InvalidExportSourceStateFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                            type InvalidExportTaskStateFault

                                                                                                                                                                                                                                                                                                            type InvalidExportTaskStateFault struct {
                                                                                                                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                              You can't cancel an export task that has completed.

                                                                                                                                                                                                                                                                                                              func (*InvalidExportTaskStateFault) Error

                                                                                                                                                                                                                                                                                                              func (*InvalidExportTaskStateFault) ErrorCode

                                                                                                                                                                                                                                                                                                              func (e *InvalidExportTaskStateFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                              func (*InvalidExportTaskStateFault) ErrorFault

                                                                                                                                                                                                                                                                                                              func (*InvalidExportTaskStateFault) ErrorMessage

                                                                                                                                                                                                                                                                                                              func (e *InvalidExportTaskStateFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                              type InvalidGlobalClusterStateFault

                                                                                                                                                                                                                                                                                                              type InvalidGlobalClusterStateFault struct {
                                                                                                                                                                                                                                                                                                              	Message *string
                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                The global cluster is in an invalid state and can't perform the requested operation.

                                                                                                                                                                                                                                                                                                                func (*InvalidGlobalClusterStateFault) Error

                                                                                                                                                                                                                                                                                                                func (*InvalidGlobalClusterStateFault) ErrorCode

                                                                                                                                                                                                                                                                                                                func (e *InvalidGlobalClusterStateFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                func (*InvalidGlobalClusterStateFault) ErrorFault

                                                                                                                                                                                                                                                                                                                func (*InvalidGlobalClusterStateFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                func (e *InvalidGlobalClusterStateFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                type InvalidOptionGroupStateFault

                                                                                                                                                                                                                                                                                                                type InvalidOptionGroupStateFault struct {
                                                                                                                                                                                                                                                                                                                	Message *string
                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                  The option group isn't in the available state.

                                                                                                                                                                                                                                                                                                                  func (*InvalidOptionGroupStateFault) Error

                                                                                                                                                                                                                                                                                                                  func (*InvalidOptionGroupStateFault) ErrorCode

                                                                                                                                                                                                                                                                                                                  func (e *InvalidOptionGroupStateFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                  func (*InvalidOptionGroupStateFault) ErrorFault

                                                                                                                                                                                                                                                                                                                  func (*InvalidOptionGroupStateFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                  func (e *InvalidOptionGroupStateFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                  type InvalidRestoreFault

                                                                                                                                                                                                                                                                                                                  type InvalidRestoreFault struct {
                                                                                                                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                    Cannot restore from VPC backup to non-VPC DB instance.

                                                                                                                                                                                                                                                                                                                    func (*InvalidRestoreFault) Error

                                                                                                                                                                                                                                                                                                                    func (e *InvalidRestoreFault) Error() string

                                                                                                                                                                                                                                                                                                                    func (*InvalidRestoreFault) ErrorCode

                                                                                                                                                                                                                                                                                                                    func (e *InvalidRestoreFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                    func (*InvalidRestoreFault) ErrorFault

                                                                                                                                                                                                                                                                                                                    func (e *InvalidRestoreFault) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                                                    func (*InvalidRestoreFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                    func (e *InvalidRestoreFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                    type InvalidS3BucketFault

                                                                                                                                                                                                                                                                                                                    type InvalidS3BucketFault struct {
                                                                                                                                                                                                                                                                                                                    	Message *string
                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                      The specified Amazon S3 bucket name can't be found or Amazon RDS isn't authorized to access the specified Amazon S3 bucket. Verify the SourceS3BucketName and S3IngestionRoleArn values and try again.

                                                                                                                                                                                                                                                                                                                      func (*InvalidS3BucketFault) Error

                                                                                                                                                                                                                                                                                                                      func (e *InvalidS3BucketFault) Error() string

                                                                                                                                                                                                                                                                                                                      func (*InvalidS3BucketFault) ErrorCode

                                                                                                                                                                                                                                                                                                                      func (e *InvalidS3BucketFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                      func (*InvalidS3BucketFault) ErrorFault

                                                                                                                                                                                                                                                                                                                      func (e *InvalidS3BucketFault) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                                                      func (*InvalidS3BucketFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                      func (e *InvalidS3BucketFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                      type InvalidSubnet

                                                                                                                                                                                                                                                                                                                      type InvalidSubnet struct {
                                                                                                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                        The requested subnet is invalid, or multiple subnets were requested that are not all in a common VPC.

                                                                                                                                                                                                                                                                                                                        func (*InvalidSubnet) Error

                                                                                                                                                                                                                                                                                                                        func (e *InvalidSubnet) Error() string

                                                                                                                                                                                                                                                                                                                        func (*InvalidSubnet) ErrorCode

                                                                                                                                                                                                                                                                                                                        func (e *InvalidSubnet) ErrorCode() string

                                                                                                                                                                                                                                                                                                                        func (*InvalidSubnet) ErrorFault

                                                                                                                                                                                                                                                                                                                        func (e *InvalidSubnet) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                                                        func (*InvalidSubnet) ErrorMessage

                                                                                                                                                                                                                                                                                                                        func (e *InvalidSubnet) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                        type InvalidVPCNetworkStateFault

                                                                                                                                                                                                                                                                                                                        type InvalidVPCNetworkStateFault struct {
                                                                                                                                                                                                                                                                                                                        	Message *string
                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                          The DB subnet group doesn't cover all Availability Zones after it's created because of users' change.

                                                                                                                                                                                                                                                                                                                          func (*InvalidVPCNetworkStateFault) Error

                                                                                                                                                                                                                                                                                                                          func (*InvalidVPCNetworkStateFault) ErrorCode

                                                                                                                                                                                                                                                                                                                          func (e *InvalidVPCNetworkStateFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                          func (*InvalidVPCNetworkStateFault) ErrorFault

                                                                                                                                                                                                                                                                                                                          func (*InvalidVPCNetworkStateFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                          func (e *InvalidVPCNetworkStateFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                          type KMSKeyNotAccessibleFault

                                                                                                                                                                                                                                                                                                                          type KMSKeyNotAccessibleFault struct {
                                                                                                                                                                                                                                                                                                                          	Message *string
                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                            An error occurred accessing an AWS KMS key.

                                                                                                                                                                                                                                                                                                                            func (*KMSKeyNotAccessibleFault) Error

                                                                                                                                                                                                                                                                                                                            func (e *KMSKeyNotAccessibleFault) Error() string

                                                                                                                                                                                                                                                                                                                            func (*KMSKeyNotAccessibleFault) ErrorCode

                                                                                                                                                                                                                                                                                                                            func (e *KMSKeyNotAccessibleFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                            func (*KMSKeyNotAccessibleFault) ErrorFault

                                                                                                                                                                                                                                                                                                                            func (e *KMSKeyNotAccessibleFault) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                                                            func (*KMSKeyNotAccessibleFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                            func (e *KMSKeyNotAccessibleFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                            type MinimumEngineVersionPerAllowedValue

                                                                                                                                                                                                                                                                                                                            type MinimumEngineVersionPerAllowedValue struct {
                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                            	// The allowed value for an option setting.
                                                                                                                                                                                                                                                                                                                            	AllowedValue *string
                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                            	// The minimum DB engine version required for the allowed value.
                                                                                                                                                                                                                                                                                                                            	MinimumEngineVersion *string
                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                              The minimum DB engine version required for each corresponding allowed value for an option setting.

                                                                                                                                                                                                                                                                                                                              type Option

                                                                                                                                                                                                                                                                                                                              type Option struct {
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// If the option requires access to a port, then this DB security group allows
                                                                                                                                                                                                                                                                                                                              	// access to the port.
                                                                                                                                                                                                                                                                                                                              	DBSecurityGroupMemberships []DBSecurityGroupMembership
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// The description of the option.
                                                                                                                                                                                                                                                                                                                              	OptionDescription *string
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// The name of the option.
                                                                                                                                                                                                                                                                                                                              	OptionName *string
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// The option settings for this option.
                                                                                                                                                                                                                                                                                                                              	OptionSettings []OptionSetting
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// The version of the option.
                                                                                                                                                                                                                                                                                                                              	OptionVersion *string
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// Indicate if this option is permanent.
                                                                                                                                                                                                                                                                                                                              	Permanent bool
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// Indicate if this option is persistent.
                                                                                                                                                                                                                                                                                                                              	Persistent bool
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// If required, the port configured for this option to use.
                                                                                                                                                                                                                                                                                                                              	Port *int32
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// If the option requires access to a port, then this VPC security group allows
                                                                                                                                                                                                                                                                                                                              	// access to the port.
                                                                                                                                                                                                                                                                                                                              	VpcSecurityGroupMemberships []VpcSecurityGroupMembership
                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                Option details.

                                                                                                                                                                                                                                                                                                                                type OptionConfiguration

                                                                                                                                                                                                                                                                                                                                type OptionConfiguration struct {
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// The configuration of options to include in a group.
                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                                                	OptionName *string
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// A list of DBSecurityGroupMembership name strings used for this option.
                                                                                                                                                                                                                                                                                                                                	DBSecurityGroupMemberships []string
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// The option settings to include in an option group.
                                                                                                                                                                                                                                                                                                                                	OptionSettings []OptionSetting
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// The version for the option.
                                                                                                                                                                                                                                                                                                                                	OptionVersion *string
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// The optional port for the option.
                                                                                                                                                                                                                                                                                                                                	Port *int32
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// A list of VpcSecurityGroupMembership name strings used for this option.
                                                                                                                                                                                                                                                                                                                                	VpcSecurityGroupMemberships []string
                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                  A list of all available options

                                                                                                                                                                                                                                                                                                                                  type OptionGroup

                                                                                                                                                                                                                                                                                                                                  type OptionGroup struct {
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// Indicates whether this option group can be applied to both VPC and non-VPC
                                                                                                                                                                                                                                                                                                                                  	// instances. The value true indicates the option group can be applied to both VPC
                                                                                                                                                                                                                                                                                                                                  	// and non-VPC instances.
                                                                                                                                                                                                                                                                                                                                  	AllowsVpcAndNonVpcInstanceMemberships bool
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// Indicates the name of the engine that this option group can be applied to.
                                                                                                                                                                                                                                                                                                                                  	EngineName *string
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// Indicates the major engine version associated with this option group.
                                                                                                                                                                                                                                                                                                                                  	MajorEngineVersion *string
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// The Amazon Resource Name (ARN) for the option group.
                                                                                                                                                                                                                                                                                                                                  	OptionGroupArn *string
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// Provides a description of the option group.
                                                                                                                                                                                                                                                                                                                                  	OptionGroupDescription *string
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// Specifies the name of the option group.
                                                                                                                                                                                                                                                                                                                                  	OptionGroupName *string
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// Indicates what options are available in the option group.
                                                                                                                                                                                                                                                                                                                                  	Options []Option
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// If AllowsVpcAndNonVpcInstanceMemberships is false, this field is blank. If
                                                                                                                                                                                                                                                                                                                                  	// AllowsVpcAndNonVpcInstanceMemberships is true and this field is blank, then this
                                                                                                                                                                                                                                                                                                                                  	// option group can be applied to both VPC and non-VPC instances. If this field
                                                                                                                                                                                                                                                                                                                                  	// contains a value, then this option group can only be applied to instances that
                                                                                                                                                                                                                                                                                                                                  	// are in the VPC indicated by this field.
                                                                                                                                                                                                                                                                                                                                  	VpcId *string
                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                  type OptionGroupAlreadyExistsFault

                                                                                                                                                                                                                                                                                                                                  type OptionGroupAlreadyExistsFault struct {
                                                                                                                                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                    The option group you are trying to create already exists.

                                                                                                                                                                                                                                                                                                                                    func (*OptionGroupAlreadyExistsFault) Error

                                                                                                                                                                                                                                                                                                                                    func (*OptionGroupAlreadyExistsFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                    func (e *OptionGroupAlreadyExistsFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                    func (*OptionGroupAlreadyExistsFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                    func (*OptionGroupAlreadyExistsFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                    func (e *OptionGroupAlreadyExistsFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                    type OptionGroupMembership

                                                                                                                                                                                                                                                                                                                                    type OptionGroupMembership struct {
                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                    	// The name of the option group that the instance belongs to.
                                                                                                                                                                                                                                                                                                                                    	OptionGroupName *string
                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                    	// The status of the DB instance's option group membership. Valid values are:
                                                                                                                                                                                                                                                                                                                                    	// in-sync, pending-apply, pending-removal, pending-maintenance-apply,
                                                                                                                                                                                                                                                                                                                                    	// pending-maintenance-removal, applying, removing, and failed.
                                                                                                                                                                                                                                                                                                                                    	Status *string
                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                      Provides information on the option groups the DB instance is a member of.

                                                                                                                                                                                                                                                                                                                                      type OptionGroupNotFoundFault

                                                                                                                                                                                                                                                                                                                                      type OptionGroupNotFoundFault struct {
                                                                                                                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                        The specified option group could not be found.

                                                                                                                                                                                                                                                                                                                                        func (*OptionGroupNotFoundFault) Error

                                                                                                                                                                                                                                                                                                                                        func (e *OptionGroupNotFoundFault) Error() string

                                                                                                                                                                                                                                                                                                                                        func (*OptionGroupNotFoundFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                        func (e *OptionGroupNotFoundFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                        func (*OptionGroupNotFoundFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                        func (e *OptionGroupNotFoundFault) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                                                                        func (*OptionGroupNotFoundFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                        func (e *OptionGroupNotFoundFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                        type OptionGroupOption

                                                                                                                                                                                                                                                                                                                                        type OptionGroupOption struct {
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// If the option requires a port, specifies the default port for the option.
                                                                                                                                                                                                                                                                                                                                        	DefaultPort *int32
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// The description of the option.
                                                                                                                                                                                                                                                                                                                                        	Description *string
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// The name of the engine that this option can be applied to.
                                                                                                                                                                                                                                                                                                                                        	EngineName *string
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// Indicates the major engine version that the option is available for.
                                                                                                                                                                                                                                                                                                                                        	MajorEngineVersion *string
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// The minimum required engine version for the option to be applied.
                                                                                                                                                                                                                                                                                                                                        	MinimumRequiredMinorEngineVersion *string
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// The name of the option.
                                                                                                                                                                                                                                                                                                                                        	Name *string
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// The option settings that are available (and the default value) for each option
                                                                                                                                                                                                                                                                                                                                        	// in an option group.
                                                                                                                                                                                                                                                                                                                                        	OptionGroupOptionSettings []OptionGroupOptionSetting
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// The versions that are available for the option.
                                                                                                                                                                                                                                                                                                                                        	OptionGroupOptionVersions []OptionVersion
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// The options that conflict with this option.
                                                                                                                                                                                                                                                                                                                                        	OptionsConflictsWith []string
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// The options that are prerequisites for this option.
                                                                                                                                                                                                                                                                                                                                        	OptionsDependedOn []string
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// Permanent options can never be removed from an option group. An option group
                                                                                                                                                                                                                                                                                                                                        	// containing a permanent option can't be removed from a DB instance.
                                                                                                                                                                                                                                                                                                                                        	Permanent bool
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// Persistent options can't be removed from an option group while DB instances are
                                                                                                                                                                                                                                                                                                                                        	// associated with the option group. If you disassociate all DB instances from the
                                                                                                                                                                                                                                                                                                                                        	// option group, your can remove the persistent option from the option group.
                                                                                                                                                                                                                                                                                                                                        	Persistent bool
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// Specifies whether the option requires a port.
                                                                                                                                                                                                                                                                                                                                        	PortRequired bool
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// If true, you must enable the Auto Minor Version Upgrade setting for your DB
                                                                                                                                                                                                                                                                                                                                        	// instance before you can use this option. You can enable Auto Minor Version
                                                                                                                                                                                                                                                                                                                                        	// Upgrade when you first create your DB instance, or by modifying your DB instance
                                                                                                                                                                                                                                                                                                                                        	// later.
                                                                                                                                                                                                                                                                                                                                        	RequiresAutoMinorEngineVersionUpgrade bool
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// If true, you can change the option to an earlier version of the option. This
                                                                                                                                                                                                                                                                                                                                        	// only applies to options that have different versions available.
                                                                                                                                                                                                                                                                                                                                        	SupportsOptionVersionDowngrade *bool
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// If true, you can only use this option with a DB instance that is in a VPC.
                                                                                                                                                                                                                                                                                                                                        	VpcOnly bool
                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                          Available option.

                                                                                                                                                                                                                                                                                                                                          type OptionGroupOptionSetting

                                                                                                                                                                                                                                                                                                                                          type OptionGroupOptionSetting struct {
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// Indicates the acceptable values for the option group option.
                                                                                                                                                                                                                                                                                                                                          	AllowedValues *string
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The DB engine specific parameter type for the option group option.
                                                                                                                                                                                                                                                                                                                                          	ApplyType *string
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The default value for the option group option.
                                                                                                                                                                                                                                                                                                                                          	DefaultValue *string
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// Boolean value where true indicates that this option group option can be changed
                                                                                                                                                                                                                                                                                                                                          	// from the default value.
                                                                                                                                                                                                                                                                                                                                          	IsModifiable bool
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// Boolean value where true indicates that a value must be specified for this
                                                                                                                                                                                                                                                                                                                                          	// option setting of the option group option.
                                                                                                                                                                                                                                                                                                                                          	IsRequired bool
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The minimum DB engine version required for the corresponding allowed value for
                                                                                                                                                                                                                                                                                                                                          	// this option setting.
                                                                                                                                                                                                                                                                                                                                          	MinimumEngineVersionPerAllowedValue []MinimumEngineVersionPerAllowedValue
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The description of the option group option.
                                                                                                                                                                                                                                                                                                                                          	SettingDescription *string
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The name of the option group option.
                                                                                                                                                                                                                                                                                                                                          	SettingName *string
                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                            Option group option settings are used to display settings available for each option with their default values and other information. These values are used with the DescribeOptionGroupOptions action.

                                                                                                                                                                                                                                                                                                                                            type OptionGroupQuotaExceededFault

                                                                                                                                                                                                                                                                                                                                            type OptionGroupQuotaExceededFault struct {
                                                                                                                                                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                              The quota of 20 option groups was exceeded for this AWS account.

                                                                                                                                                                                                                                                                                                                                              func (*OptionGroupQuotaExceededFault) Error

                                                                                                                                                                                                                                                                                                                                              func (*OptionGroupQuotaExceededFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                              func (e *OptionGroupQuotaExceededFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                              func (*OptionGroupQuotaExceededFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                              func (*OptionGroupQuotaExceededFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                              func (e *OptionGroupQuotaExceededFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                              type OptionSetting

                                                                                                                                                                                                                                                                                                                                              type OptionSetting struct {
                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                              	// The allowed values of the option setting.
                                                                                                                                                                                                                                                                                                                                              	AllowedValues *string
                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                              	// The DB engine specific parameter type.
                                                                                                                                                                                                                                                                                                                                              	ApplyType *string
                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                              	// The data type of the option setting.
                                                                                                                                                                                                                                                                                                                                              	DataType *string
                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                              	// The default value of the option setting.
                                                                                                                                                                                                                                                                                                                                              	DefaultValue *string
                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                              	// The description of the option setting.
                                                                                                                                                                                                                                                                                                                                              	Description *string
                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                              	// Indicates if the option setting is part of a collection.
                                                                                                                                                                                                                                                                                                                                              	IsCollection bool
                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                              	// A Boolean value that, when true, indicates the option setting can be modified
                                                                                                                                                                                                                                                                                                                                              	// from the default.
                                                                                                                                                                                                                                                                                                                                              	IsModifiable bool
                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                              	// The name of the option that has settings that you can set.
                                                                                                                                                                                                                                                                                                                                              	Name *string
                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                              	// The current value of the option setting.
                                                                                                                                                                                                                                                                                                                                              	Value *string
                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                Option settings are the actual settings being applied or configured for that option. It is used when you modify an option group or describe option groups. For example, the NATIVE_NETWORK_ENCRYPTION option has a setting called SQLNET.ENCRYPTION_SERVER that can have several different values.

                                                                                                                                                                                                                                                                                                                                                type OptionVersion

                                                                                                                                                                                                                                                                                                                                                type OptionVersion struct {
                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                	// True if the version is the default version of the option, and otherwise false.
                                                                                                                                                                                                                                                                                                                                                	IsDefault bool
                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                	// The version of the option.
                                                                                                                                                                                                                                                                                                                                                	Version *string
                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                  The version for an option. Option group option versions are returned by the DescribeOptionGroupOptions action.

                                                                                                                                                                                                                                                                                                                                                  type OrderableDBInstanceOption

                                                                                                                                                                                                                                                                                                                                                  type OrderableDBInstanceOption struct {
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// The Availability Zone group for a DB instance.
                                                                                                                                                                                                                                                                                                                                                  	AvailabilityZoneGroup *string
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// A list of Availability Zones for a DB instance.
                                                                                                                                                                                                                                                                                                                                                  	AvailabilityZones []AvailabilityZone
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// A list of the available processor features for the DB instance class of a DB
                                                                                                                                                                                                                                                                                                                                                  	// instance.
                                                                                                                                                                                                                                                                                                                                                  	AvailableProcessorFeatures []AvailableProcessorFeature
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// The DB instance class for a DB instance.
                                                                                                                                                                                                                                                                                                                                                  	DBInstanceClass *string
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// The engine type of a DB instance.
                                                                                                                                                                                                                                                                                                                                                  	Engine *string
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// The engine version of a DB instance.
                                                                                                                                                                                                                                                                                                                                                  	EngineVersion *string
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// The license model for a DB instance.
                                                                                                                                                                                                                                                                                                                                                  	LicenseModel *string
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// Maximum total provisioned IOPS for a DB instance.
                                                                                                                                                                                                                                                                                                                                                  	MaxIopsPerDbInstance *int32
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// Maximum provisioned IOPS per GiB for a DB instance.
                                                                                                                                                                                                                                                                                                                                                  	MaxIopsPerGib *float64
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// Maximum storage size for a DB instance.
                                                                                                                                                                                                                                                                                                                                                  	MaxStorageSize *int32
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// Minimum total provisioned IOPS for a DB instance.
                                                                                                                                                                                                                                                                                                                                                  	MinIopsPerDbInstance *int32
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// Minimum provisioned IOPS per GiB for a DB instance.
                                                                                                                                                                                                                                                                                                                                                  	MinIopsPerGib *float64
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// Minimum storage size for a DB instance.
                                                                                                                                                                                                                                                                                                                                                  	MinStorageSize *int32
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// Indicates whether a DB instance is Multi-AZ capable.
                                                                                                                                                                                                                                                                                                                                                  	MultiAZCapable bool
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// Whether a DB instance supports RDS on Outposts. For more information about RDS
                                                                                                                                                                                                                                                                                                                                                  	// on Outposts, see Amazon RDS on AWS Outposts
                                                                                                                                                                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-on-outposts.html) in
                                                                                                                                                                                                                                                                                                                                                  	// the Amazon RDS User Guide.
                                                                                                                                                                                                                                                                                                                                                  	OutpostCapable bool
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// Indicates whether a DB instance can have a read replica.
                                                                                                                                                                                                                                                                                                                                                  	ReadReplicaCapable bool
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// Indicates the storage type for a DB instance.
                                                                                                                                                                                                                                                                                                                                                  	StorageType *string
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// A list of the supported DB engine modes.
                                                                                                                                                                                                                                                                                                                                                  	SupportedEngineModes []string
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// Indicates whether a DB instance supports Enhanced Monitoring at intervals from 1
                                                                                                                                                                                                                                                                                                                                                  	// to 60 seconds.
                                                                                                                                                                                                                                                                                                                                                  	SupportsEnhancedMonitoring bool
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// A value that indicates whether you can use Aurora global databases with a
                                                                                                                                                                                                                                                                                                                                                  	// specific combination of other DB engine attributes.
                                                                                                                                                                                                                                                                                                                                                  	SupportsGlobalDatabases bool
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// Indicates whether a DB instance supports IAM database authentication.
                                                                                                                                                                                                                                                                                                                                                  	SupportsIAMDatabaseAuthentication bool
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// Indicates whether a DB instance supports provisioned IOPS.
                                                                                                                                                                                                                                                                                                                                                  	SupportsIops bool
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// Whether a DB instance supports Kerberos Authentication.
                                                                                                                                                                                                                                                                                                                                                  	SupportsKerberosAuthentication *bool
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// True if a DB instance supports Performance Insights, otherwise false.
                                                                                                                                                                                                                                                                                                                                                  	SupportsPerformanceInsights bool
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// Whether Amazon RDS can automatically scale storage for DB instances that use the
                                                                                                                                                                                                                                                                                                                                                  	// specified DB instance class.
                                                                                                                                                                                                                                                                                                                                                  	SupportsStorageAutoscaling *bool
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// Indicates whether a DB instance supports encrypted storage.
                                                                                                                                                                                                                                                                                                                                                  	SupportsStorageEncryption bool
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// Indicates whether a DB instance is in a VPC.
                                                                                                                                                                                                                                                                                                                                                  	Vpc bool
                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                    Contains a list of available options for a DB instance. This data type is used as a response element in the DescribeOrderableDBInstanceOptions action.

                                                                                                                                                                                                                                                                                                                                                    type Outpost

                                                                                                                                                                                                                                                                                                                                                    type Outpost struct {
                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                    	// The Amazon Resource Name (ARN) of the Outpost.
                                                                                                                                                                                                                                                                                                                                                    	Arn *string
                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                      A data type that represents an Outpost. For more information about RDS on Outposts, see Amazon RDS on AWS Outposts (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-on-outposts.html) in the Amazon RDS User Guide.

                                                                                                                                                                                                                                                                                                                                                      type Parameter

                                                                                                                                                                                                                                                                                                                                                      type Parameter struct {
                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                      	// Specifies the valid range of values for the parameter.
                                                                                                                                                                                                                                                                                                                                                      	AllowedValues *string
                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                      	// Indicates when to apply parameter updates.
                                                                                                                                                                                                                                                                                                                                                      	ApplyMethod ApplyMethod
                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                      	// Specifies the engine specific parameters type.
                                                                                                                                                                                                                                                                                                                                                      	ApplyType *string
                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                      	// Specifies the valid data type for the parameter.
                                                                                                                                                                                                                                                                                                                                                      	DataType *string
                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                      	// Provides a description of the parameter.
                                                                                                                                                                                                                                                                                                                                                      	Description *string
                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                      	// Indicates whether (true) or not (false) the parameter can be modified. Some
                                                                                                                                                                                                                                                                                                                                                      	// parameters have security or operational implications that prevent them from
                                                                                                                                                                                                                                                                                                                                                      	// being changed.
                                                                                                                                                                                                                                                                                                                                                      	IsModifiable bool
                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                      	// The earliest engine version to which the parameter can apply.
                                                                                                                                                                                                                                                                                                                                                      	MinimumEngineVersion *string
                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                      	// Specifies the name of the parameter.
                                                                                                                                                                                                                                                                                                                                                      	ParameterName *string
                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                      	// Specifies the value of the parameter.
                                                                                                                                                                                                                                                                                                                                                      	ParameterValue *string
                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                      	// Indicates the source of the parameter value.
                                                                                                                                                                                                                                                                                                                                                      	Source *string
                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                      	// The valid DB engine modes.
                                                                                                                                                                                                                                                                                                                                                      	SupportedEngineModes []string
                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                        This data type is used as a request parameter in the ModifyDBParameterGroup and ResetDBParameterGroup actions. This data type is used as a response element in the DescribeEngineDefaultParameters and DescribeDBParameters actions.

                                                                                                                                                                                                                                                                                                                                                        type PendingCloudwatchLogsExports

                                                                                                                                                                                                                                                                                                                                                        type PendingCloudwatchLogsExports struct {
                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                        	// Log types that are in the process of being enabled. After they are enabled,
                                                                                                                                                                                                                                                                                                                                                        	// these log types are exported to CloudWatch Logs.
                                                                                                                                                                                                                                                                                                                                                        	LogTypesToDisable []string
                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                        	// Log types that are in the process of being deactivated. After they are
                                                                                                                                                                                                                                                                                                                                                        	// deactivated, these log types aren't exported to CloudWatch Logs.
                                                                                                                                                                                                                                                                                                                                                        	LogTypesToEnable []string
                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                          A list of the log types whose configuration is still pending. In other words, these log types are in the process of being activated or deactivated.

                                                                                                                                                                                                                                                                                                                                                          type PendingMaintenanceAction

                                                                                                                                                                                                                                                                                                                                                          type PendingMaintenanceAction struct {
                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                          	// The type of pending maintenance action that is available for the resource. Valid
                                                                                                                                                                                                                                                                                                                                                          	// actions are system-update, db-upgrade, hardware-maintenance, and
                                                                                                                                                                                                                                                                                                                                                          	// ca-certificate-rotation.
                                                                                                                                                                                                                                                                                                                                                          	Action *string
                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                          	// The date of the maintenance window when the action is applied. The maintenance
                                                                                                                                                                                                                                                                                                                                                          	// action is applied to the resource during its first maintenance window after this
                                                                                                                                                                                                                                                                                                                                                          	// date.
                                                                                                                                                                                                                                                                                                                                                          	AutoAppliedAfterDate *time.Time
                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                          	// The effective date when the pending maintenance action is applied to the
                                                                                                                                                                                                                                                                                                                                                          	// resource. This date takes into account opt-in requests received from the
                                                                                                                                                                                                                                                                                                                                                          	// ApplyPendingMaintenanceAction API, the AutoAppliedAfterDate, and the
                                                                                                                                                                                                                                                                                                                                                          	// ForcedApplyDate. This value is blank if an opt-in request has not been received
                                                                                                                                                                                                                                                                                                                                                          	// and nothing has been specified as AutoAppliedAfterDate or ForcedApplyDate.
                                                                                                                                                                                                                                                                                                                                                          	CurrentApplyDate *time.Time
                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                          	// A description providing more detail about the maintenance action.
                                                                                                                                                                                                                                                                                                                                                          	Description *string
                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                          	// The date when the maintenance action is automatically applied. On this date, the
                                                                                                                                                                                                                                                                                                                                                          	// maintenance action is applied to the resource as soon as possible, regardless of
                                                                                                                                                                                                                                                                                                                                                          	// the maintenance window for the resource. There might be a delay of one or more
                                                                                                                                                                                                                                                                                                                                                          	// days from this date before the maintenance action is applied.
                                                                                                                                                                                                                                                                                                                                                          	ForcedApplyDate *time.Time
                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                          	// Indicates the type of opt-in request that has been received for the resource.
                                                                                                                                                                                                                                                                                                                                                          	OptInStatus *string
                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                            Provides information about a pending maintenance action for a resource.

                                                                                                                                                                                                                                                                                                                                                            type PendingModifiedValues

                                                                                                                                                                                                                                                                                                                                                            type PendingModifiedValues struct {
                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                            	// The allocated storage size for the DB instance specified in gibibytes .
                                                                                                                                                                                                                                                                                                                                                            	AllocatedStorage *int32
                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                            	// The number of days for which automated backups are retained.
                                                                                                                                                                                                                                                                                                                                                            	BackupRetentionPeriod *int32
                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                            	// The identifier of the CA certificate for the DB instance.
                                                                                                                                                                                                                                                                                                                                                            	CACertificateIdentifier *string
                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                            	// The name of the compute and memory capacity class for the DB instance.
                                                                                                                                                                                                                                                                                                                                                            	DBInstanceClass *string
                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                            	// The database identifier for the DB instance.
                                                                                                                                                                                                                                                                                                                                                            	DBInstanceIdentifier *string
                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                            	// The DB subnet group for the DB instance.
                                                                                                                                                                                                                                                                                                                                                            	DBSubnetGroupName *string
                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                            	// The database engine version.
                                                                                                                                                                                                                                                                                                                                                            	EngineVersion *string
                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                            	// Whether mapping of AWS Identity and Access Management (IAM) accounts to database
                                                                                                                                                                                                                                                                                                                                                            	// accounts is enabled.
                                                                                                                                                                                                                                                                                                                                                            	IAMDatabaseAuthenticationEnabled *bool
                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                            	// The Provisioned IOPS value for the DB instance.
                                                                                                                                                                                                                                                                                                                                                            	Iops *int32
                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                            	// The license model for the DB instance. Valid values: license-included |
                                                                                                                                                                                                                                                                                                                                                            	// bring-your-own-license | general-public-license
                                                                                                                                                                                                                                                                                                                                                            	LicenseModel *string
                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                            	// The master credentials for the DB instance.
                                                                                                                                                                                                                                                                                                                                                            	MasterUserPassword *string
                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                            	// Indicates that the Single-AZ DB instance will change to a Multi-AZ deployment.
                                                                                                                                                                                                                                                                                                                                                            	MultiAZ *bool
                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                            	// A list of the log types whose configuration is still pending. In other words,
                                                                                                                                                                                                                                                                                                                                                            	// these log types are in the process of being activated or deactivated.
                                                                                                                                                                                                                                                                                                                                                            	PendingCloudwatchLogsExports *PendingCloudwatchLogsExports
                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                            	// The port for the DB instance.
                                                                                                                                                                                                                                                                                                                                                            	Port *int32
                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                            	// The number of CPU cores and the number of threads per core for the DB instance
                                                                                                                                                                                                                                                                                                                                                            	// class of the DB instance.
                                                                                                                                                                                                                                                                                                                                                            	ProcessorFeatures []ProcessorFeature
                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                            	// The storage type of the DB instance.
                                                                                                                                                                                                                                                                                                                                                            	StorageType *string
                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                              This data type is used as a response element in the ModifyDBInstance action and contains changes that will be applied during the next maintenance window.

                                                                                                                                                                                                                                                                                                                                                              type PointInTimeRestoreNotEnabledFault

                                                                                                                                                                                                                                                                                                                                                              type PointInTimeRestoreNotEnabledFault struct {
                                                                                                                                                                                                                                                                                                                                                              	Message *string
                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                SourceDBInstanceIdentifier refers to a DB instance with BackupRetentionPeriod equal to 0.

                                                                                                                                                                                                                                                                                                                                                                func (*PointInTimeRestoreNotEnabledFault) Error

                                                                                                                                                                                                                                                                                                                                                                func (*PointInTimeRestoreNotEnabledFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                func (*PointInTimeRestoreNotEnabledFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                func (*PointInTimeRestoreNotEnabledFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                func (e *PointInTimeRestoreNotEnabledFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                type ProcessorFeature

                                                                                                                                                                                                                                                                                                                                                                type ProcessorFeature struct {
                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                	// The name of the processor feature. Valid names are coreCount and threadsPerCore.
                                                                                                                                                                                                                                                                                                                                                                	Name *string
                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                	// The value of a processor feature name.
                                                                                                                                                                                                                                                                                                                                                                	Value *string
                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                  Contains the processor features of a DB instance class. To specify the number of CPU cores, use the coreCount feature name for the Name parameter. To specify the number of threads per core, use the threadsPerCore feature name for the Name parameter. You can set the processor features of the DB instance class for a DB instance when you call one of the following actions:

                                                                                                                                                                                                                                                                                                                                                                  * CreateDBInstance

                                                                                                                                                                                                                                                                                                                                                                  * ModifyDBInstance

                                                                                                                                                                                                                                                                                                                                                                  * RestoreDBInstanceFromDBSnapshot

                                                                                                                                                                                                                                                                                                                                                                  * RestoreDBInstanceFromS3

                                                                                                                                                                                                                                                                                                                                                                  * RestoreDBInstanceToPointInTime

                                                                                                                                                                                                                                                                                                                                                                  You can view the valid processor values for a particular instance class by calling the DescribeOrderableDBInstanceOptions action and specifying the instance class for the DBInstanceClass parameter. In addition, you can use the following actions for DB instance class processor information:

                                                                                                                                                                                                                                                                                                                                                                  * DescribeDBInstances

                                                                                                                                                                                                                                                                                                                                                                  * DescribeDBSnapshots

                                                                                                                                                                                                                                                                                                                                                                  * DescribeValidDBInstanceModifications

                                                                                                                                                                                                                                                                                                                                                                  If you call DescribeDBInstances, ProcessorFeature returns non-null values only if the following conditions are met:

                                                                                                                                                                                                                                                                                                                                                                  * You are accessing an Oracle DB instance.

                                                                                                                                                                                                                                                                                                                                                                  * Your Oracle DB instance class supports configuring the number of CPU cores and threads per core.

                                                                                                                                                                                                                                                                                                                                                                  * The current number CPU cores and threads is set to a non-default value.

                                                                                                                                                                                                                                                                                                                                                                  For more information, see Configuring the Processor of the DB Instance Class (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.DBInstanceClass.html#USER_ConfigureProcessor) in the Amazon RDS User Guide.

                                                                                                                                                                                                                                                                                                                                                                  type ProvisionedIopsNotAvailableInAZFault

                                                                                                                                                                                                                                                                                                                                                                  type ProvisionedIopsNotAvailableInAZFault struct {
                                                                                                                                                                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                    Provisioned IOPS not available in the specified Availability Zone.

                                                                                                                                                                                                                                                                                                                                                                    func (*ProvisionedIopsNotAvailableInAZFault) Error

                                                                                                                                                                                                                                                                                                                                                                    func (*ProvisionedIopsNotAvailableInAZFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                    func (*ProvisionedIopsNotAvailableInAZFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                    func (*ProvisionedIopsNotAvailableInAZFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                    func (e *ProvisionedIopsNotAvailableInAZFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                    type Range

                                                                                                                                                                                                                                                                                                                                                                    type Range struct {
                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                    	// The minimum value in the range.
                                                                                                                                                                                                                                                                                                                                                                    	From int32
                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                    	// The step value for the range. For example, if you have a range of 5,000 to
                                                                                                                                                                                                                                                                                                                                                                    	// 10,000, with a step value of 1,000, the valid values start at 5,000 and step up
                                                                                                                                                                                                                                                                                                                                                                    	// by 1,000. Even though 7,500 is within the range, it isn't a valid value for the
                                                                                                                                                                                                                                                                                                                                                                    	// range. The valid values are 5,000, 6,000, 7,000, 8,000...
                                                                                                                                                                                                                                                                                                                                                                    	Step *int32
                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                    	// The maximum value in the range.
                                                                                                                                                                                                                                                                                                                                                                    	To int32
                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                      A range of integer values.

                                                                                                                                                                                                                                                                                                                                                                      type RecurringCharge

                                                                                                                                                                                                                                                                                                                                                                      type RecurringCharge struct {
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// The amount of the recurring charge.
                                                                                                                                                                                                                                                                                                                                                                      	RecurringChargeAmount float64
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// The frequency of the recurring charge.
                                                                                                                                                                                                                                                                                                                                                                      	RecurringChargeFrequency *string
                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                        This data type is used as a response element in the DescribeReservedDBInstances and DescribeReservedDBInstancesOfferings actions.

                                                                                                                                                                                                                                                                                                                                                                        type ReplicaMode

                                                                                                                                                                                                                                                                                                                                                                        type ReplicaMode string
                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                        	ReplicaModeOpenReadOnly ReplicaMode = "open-read-only"
                                                                                                                                                                                                                                                                                                                                                                        	ReplicaModeMounted      ReplicaMode = "mounted"
                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                          Enum values for ReplicaMode

                                                                                                                                                                                                                                                                                                                                                                          func (ReplicaMode) Values

                                                                                                                                                                                                                                                                                                                                                                          func (ReplicaMode) Values() []ReplicaMode

                                                                                                                                                                                                                                                                                                                                                                            Values returns all known values for ReplicaMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                            type ReservedDBInstance

                                                                                                                                                                                                                                                                                                                                                                            type ReservedDBInstance struct {
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// The currency code for the reserved DB instance.
                                                                                                                                                                                                                                                                                                                                                                            	CurrencyCode *string
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// The DB instance class for the reserved DB instance.
                                                                                                                                                                                                                                                                                                                                                                            	DBInstanceClass *string
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// The number of reserved DB instances.
                                                                                                                                                                                                                                                                                                                                                                            	DBInstanceCount int32
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// The duration of the reservation in seconds.
                                                                                                                                                                                                                                                                                                                                                                            	Duration int32
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// The fixed price charged for this reserved DB instance.
                                                                                                                                                                                                                                                                                                                                                                            	FixedPrice float64
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// The unique identifier for the lease associated with the reserved DB instance.
                                                                                                                                                                                                                                                                                                                                                                            	// AWS Support might request the lease ID for an issue related to a reserved DB
                                                                                                                                                                                                                                                                                                                                                                            	// instance.
                                                                                                                                                                                                                                                                                                                                                                            	LeaseId *string
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// Indicates if the reservation applies to Multi-AZ deployments.
                                                                                                                                                                                                                                                                                                                                                                            	MultiAZ bool
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// The offering type of this reserved DB instance.
                                                                                                                                                                                                                                                                                                                                                                            	OfferingType *string
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// The description of the reserved DB instance.
                                                                                                                                                                                                                                                                                                                                                                            	ProductDescription *string
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// The recurring price charged to run this reserved DB instance.
                                                                                                                                                                                                                                                                                                                                                                            	RecurringCharges []RecurringCharge
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// The Amazon Resource Name (ARN) for the reserved DB instance.
                                                                                                                                                                                                                                                                                                                                                                            	ReservedDBInstanceArn *string
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// The unique identifier for the reservation.
                                                                                                                                                                                                                                                                                                                                                                            	ReservedDBInstanceId *string
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// The offering identifier.
                                                                                                                                                                                                                                                                                                                                                                            	ReservedDBInstancesOfferingId *string
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// The time the reservation started.
                                                                                                                                                                                                                                                                                                                                                                            	StartTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// The state of the reserved DB instance.
                                                                                                                                                                                                                                                                                                                                                                            	State *string
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// The hourly price charged for this reserved DB instance.
                                                                                                                                                                                                                                                                                                                                                                            	UsagePrice float64
                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                              This data type is used as a response element in the DescribeReservedDBInstances and PurchaseReservedDBInstancesOffering actions.

                                                                                                                                                                                                                                                                                                                                                                              type ReservedDBInstanceAlreadyExistsFault

                                                                                                                                                                                                                                                                                                                                                                              type ReservedDBInstanceAlreadyExistsFault struct {
                                                                                                                                                                                                                                                                                                                                                                              	Message *string
                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                User already has a reservation with the given identifier.

                                                                                                                                                                                                                                                                                                                                                                                func (*ReservedDBInstanceAlreadyExistsFault) Error

                                                                                                                                                                                                                                                                                                                                                                                func (*ReservedDBInstanceAlreadyExistsFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                func (*ReservedDBInstanceAlreadyExistsFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                func (*ReservedDBInstanceAlreadyExistsFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                func (e *ReservedDBInstanceAlreadyExistsFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                type ReservedDBInstanceNotFoundFault

                                                                                                                                                                                                                                                                                                                                                                                type ReservedDBInstanceNotFoundFault struct {
                                                                                                                                                                                                                                                                                                                                                                                	Message *string
                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                  The specified reserved DB Instance not found.

                                                                                                                                                                                                                                                                                                                                                                                  func (*ReservedDBInstanceNotFoundFault) Error

                                                                                                                                                                                                                                                                                                                                                                                  func (*ReservedDBInstanceNotFoundFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                  func (e *ReservedDBInstanceNotFoundFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                  func (*ReservedDBInstanceNotFoundFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                  func (*ReservedDBInstanceNotFoundFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                  func (e *ReservedDBInstanceNotFoundFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                  type ReservedDBInstanceQuotaExceededFault

                                                                                                                                                                                                                                                                                                                                                                                  type ReservedDBInstanceQuotaExceededFault struct {
                                                                                                                                                                                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                    Request would exceed the user's DB Instance quota.

                                                                                                                                                                                                                                                                                                                                                                                    func (*ReservedDBInstanceQuotaExceededFault) Error

                                                                                                                                                                                                                                                                                                                                                                                    func (*ReservedDBInstanceQuotaExceededFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                    func (*ReservedDBInstanceQuotaExceededFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                    func (*ReservedDBInstanceQuotaExceededFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                    func (e *ReservedDBInstanceQuotaExceededFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                    type ReservedDBInstancesOffering

                                                                                                                                                                                                                                                                                                                                                                                    type ReservedDBInstancesOffering struct {
                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                    	// The currency code for the reserved DB instance offering.
                                                                                                                                                                                                                                                                                                                                                                                    	CurrencyCode *string
                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                    	// The DB instance class for the reserved DB instance.
                                                                                                                                                                                                                                                                                                                                                                                    	DBInstanceClass *string
                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                    	// The duration of the offering in seconds.
                                                                                                                                                                                                                                                                                                                                                                                    	Duration int32
                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                    	// The fixed price charged for this offering.
                                                                                                                                                                                                                                                                                                                                                                                    	FixedPrice float64
                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                    	// Indicates if the offering applies to Multi-AZ deployments.
                                                                                                                                                                                                                                                                                                                                                                                    	MultiAZ bool
                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                    	// The offering type.
                                                                                                                                                                                                                                                                                                                                                                                    	OfferingType *string
                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                    	// The database engine used by the offering.
                                                                                                                                                                                                                                                                                                                                                                                    	ProductDescription *string
                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                    	// The recurring price charged to run this reserved DB instance.
                                                                                                                                                                                                                                                                                                                                                                                    	RecurringCharges []RecurringCharge
                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                    	// The offering identifier.
                                                                                                                                                                                                                                                                                                                                                                                    	ReservedDBInstancesOfferingId *string
                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                    	// The hourly price charged for this offering.
                                                                                                                                                                                                                                                                                                                                                                                    	UsagePrice float64
                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                      This data type is used as a response element in the DescribeReservedDBInstancesOfferings action.

                                                                                                                                                                                                                                                                                                                                                                                      type ReservedDBInstancesOfferingNotFoundFault

                                                                                                                                                                                                                                                                                                                                                                                      type ReservedDBInstancesOfferingNotFoundFault struct {
                                                                                                                                                                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                        Specified offering does not exist.

                                                                                                                                                                                                                                                                                                                                                                                        func (*ReservedDBInstancesOfferingNotFoundFault) Error

                                                                                                                                                                                                                                                                                                                                                                                        func (*ReservedDBInstancesOfferingNotFoundFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                        func (*ReservedDBInstancesOfferingNotFoundFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                        func (*ReservedDBInstancesOfferingNotFoundFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                        type ResourceNotFoundFault

                                                                                                                                                                                                                                                                                                                                                                                        type ResourceNotFoundFault struct {
                                                                                                                                                                                                                                                                                                                                                                                        	Message *string
                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                          The specified resource ID was not found.

                                                                                                                                                                                                                                                                                                                                                                                          func (*ResourceNotFoundFault) Error

                                                                                                                                                                                                                                                                                                                                                                                          func (e *ResourceNotFoundFault) Error() string

                                                                                                                                                                                                                                                                                                                                                                                          func (*ResourceNotFoundFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                          func (e *ResourceNotFoundFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                          func (*ResourceNotFoundFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                          func (e *ResourceNotFoundFault) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                          func (*ResourceNotFoundFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                          func (e *ResourceNotFoundFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                          type ResourcePendingMaintenanceActions

                                                                                                                                                                                                                                                                                                                                                                                          type ResourcePendingMaintenanceActions struct {
                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                          	// A list that provides details about the pending maintenance actions for the
                                                                                                                                                                                                                                                                                                                                                                                          	// resource.
                                                                                                                                                                                                                                                                                                                                                                                          	PendingMaintenanceActionDetails []PendingMaintenanceAction
                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                          	// The ARN of the resource that has pending maintenance actions.
                                                                                                                                                                                                                                                                                                                                                                                          	ResourceIdentifier *string
                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                            Describes the pending maintenance actions for a resource.

                                                                                                                                                                                                                                                                                                                                                                                            type RestoreWindow

                                                                                                                                                                                                                                                                                                                                                                                            type RestoreWindow struct {
                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                            	// The earliest time you can restore an instance to.
                                                                                                                                                                                                                                                                                                                                                                                            	EarliestTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                            	// The latest time you can restore an instance to.
                                                                                                                                                                                                                                                                                                                                                                                            	LatestTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                              Earliest and latest time an instance can be restored to:

                                                                                                                                                                                                                                                                                                                                                                                              type SNSInvalidTopicFault

                                                                                                                                                                                                                                                                                                                                                                                              type SNSInvalidTopicFault struct {
                                                                                                                                                                                                                                                                                                                                                                                              	Message *string
                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                SNS has responded that there is a problem with the SND topic specified.

                                                                                                                                                                                                                                                                                                                                                                                                func (*SNSInvalidTopicFault) Error

                                                                                                                                                                                                                                                                                                                                                                                                func (e *SNSInvalidTopicFault) Error() string

                                                                                                                                                                                                                                                                                                                                                                                                func (*SNSInvalidTopicFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                                func (e *SNSInvalidTopicFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                                func (*SNSInvalidTopicFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                                func (e *SNSInvalidTopicFault) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                                func (*SNSInvalidTopicFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                                func (e *SNSInvalidTopicFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                                type SNSNoAuthorizationFault

                                                                                                                                                                                                                                                                                                                                                                                                type SNSNoAuthorizationFault struct {
                                                                                                                                                                                                                                                                                                                                                                                                	Message *string
                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                  You do not have permission to publish to the SNS topic ARN.

                                                                                                                                                                                                                                                                                                                                                                                                  func (*SNSNoAuthorizationFault) Error

                                                                                                                                                                                                                                                                                                                                                                                                  func (e *SNSNoAuthorizationFault) Error() string

                                                                                                                                                                                                                                                                                                                                                                                                  func (*SNSNoAuthorizationFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                                  func (e *SNSNoAuthorizationFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                                  func (*SNSNoAuthorizationFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                                  func (e *SNSNoAuthorizationFault) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                                  func (*SNSNoAuthorizationFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                                  func (e *SNSNoAuthorizationFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                                  type SNSTopicArnNotFoundFault

                                                                                                                                                                                                                                                                                                                                                                                                  type SNSTopicArnNotFoundFault struct {
                                                                                                                                                                                                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                    The SNS topic ARN does not exist.

                                                                                                                                                                                                                                                                                                                                                                                                    func (*SNSTopicArnNotFoundFault) Error

                                                                                                                                                                                                                                                                                                                                                                                                    func (e *SNSTopicArnNotFoundFault) Error() string

                                                                                                                                                                                                                                                                                                                                                                                                    func (*SNSTopicArnNotFoundFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                                    func (e *SNSTopicArnNotFoundFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                                    func (*SNSTopicArnNotFoundFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                                    func (e *SNSTopicArnNotFoundFault) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                                    func (*SNSTopicArnNotFoundFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                                    func (e *SNSTopicArnNotFoundFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                                    type ScalingConfiguration

                                                                                                                                                                                                                                                                                                                                                                                                    type ScalingConfiguration struct {
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// A value that indicates whether to allow or disallow automatic pause for an
                                                                                                                                                                                                                                                                                                                                                                                                    	// Aurora DB cluster in serverless DB engine mode. A DB cluster can be paused only
                                                                                                                                                                                                                                                                                                                                                                                                    	// when it's idle (it has no connections). If a DB cluster is paused for more than
                                                                                                                                                                                                                                                                                                                                                                                                    	// seven days, the DB cluster might be backed up with a snapshot. In this case, the
                                                                                                                                                                                                                                                                                                                                                                                                    	// DB cluster is restored when there is a request to connect to it.
                                                                                                                                                                                                                                                                                                                                                                                                    	AutoPause *bool
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// The maximum capacity for an Aurora DB cluster in serverless DB engine mode. For
                                                                                                                                                                                                                                                                                                                                                                                                    	// Aurora MySQL, valid capacity values are 1, 2, 4, 8, 16, 32, 64, 128, and 256.
                                                                                                                                                                                                                                                                                                                                                                                                    	// For Aurora PostgreSQL, valid capacity values are 2, 4, 8, 16, 32, 64, 192, and
                                                                                                                                                                                                                                                                                                                                                                                                    	// 384. The maximum capacity must be greater than or equal to the minimum capacity.
                                                                                                                                                                                                                                                                                                                                                                                                    	MaxCapacity *int32
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// The minimum capacity for an Aurora DB cluster in serverless DB engine mode. For
                                                                                                                                                                                                                                                                                                                                                                                                    	// Aurora MySQL, valid capacity values are 1, 2, 4, 8, 16, 32, 64, 128, and 256.
                                                                                                                                                                                                                                                                                                                                                                                                    	// For Aurora PostgreSQL, valid capacity values are 2, 4, 8, 16, 32, 64, 192, and
                                                                                                                                                                                                                                                                                                                                                                                                    	// 384. The minimum capacity must be less than or equal to the maximum capacity.
                                                                                                                                                                                                                                                                                                                                                                                                    	MinCapacity *int32
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// The time, in seconds, before an Aurora DB cluster in serverless mode is paused.
                                                                                                                                                                                                                                                                                                                                                                                                    	SecondsUntilAutoPause *int32
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// The action to take when the timeout is reached, either ForceApplyCapacityChange
                                                                                                                                                                                                                                                                                                                                                                                                    	// or RollbackCapacityChange. ForceApplyCapacityChange sets the capacity to the
                                                                                                                                                                                                                                                                                                                                                                                                    	// specified value as soon as possible. RollbackCapacityChange, the default,
                                                                                                                                                                                                                                                                                                                                                                                                    	// ignores the capacity change if a scaling point isn't found in the timeout
                                                                                                                                                                                                                                                                                                                                                                                                    	// period. If you specify ForceApplyCapacityChange, connections that prevent Aurora
                                                                                                                                                                                                                                                                                                                                                                                                    	// Serverless from finding a scaling point might be dropped. For more information,
                                                                                                                                                                                                                                                                                                                                                                                                    	// see  Autoscaling for Aurora Serverless
                                                                                                                                                                                                                                                                                                                                                                                                    	// (https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-serverless.how-it-works.html#aurora-serverless.how-it-works.auto-scaling)
                                                                                                                                                                                                                                                                                                                                                                                                    	// in the Amazon Aurora User Guide.
                                                                                                                                                                                                                                                                                                                                                                                                    	TimeoutAction *string
                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                      Contains the scaling configuration of an Aurora Serverless DB cluster. For more information, see Using Amazon Aurora Serverless (https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-serverless.html) in the Amazon Aurora User Guide.

                                                                                                                                                                                                                                                                                                                                                                                                      type ScalingConfigurationInfo

                                                                                                                                                                                                                                                                                                                                                                                                      type ScalingConfigurationInfo struct {
                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                      	// A value that indicates whether automatic pause is allowed for the Aurora DB
                                                                                                                                                                                                                                                                                                                                                                                                      	// cluster in serverless DB engine mode. When the value is set to false for an
                                                                                                                                                                                                                                                                                                                                                                                                      	// Aurora Serverless DB cluster, the DB cluster automatically resumes.
                                                                                                                                                                                                                                                                                                                                                                                                      	AutoPause *bool
                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                      	// The maximum capacity for an Aurora DB cluster in serverless DB engine mode.
                                                                                                                                                                                                                                                                                                                                                                                                      	MaxCapacity *int32
                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                      	// The maximum capacity for the Aurora DB cluster in serverless DB engine mode.
                                                                                                                                                                                                                                                                                                                                                                                                      	MinCapacity *int32
                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                      	// The remaining amount of time, in seconds, before the Aurora DB cluster in
                                                                                                                                                                                                                                                                                                                                                                                                      	// serverless mode is paused. A DB cluster can be paused only when it's idle (it
                                                                                                                                                                                                                                                                                                                                                                                                      	// has no connections).
                                                                                                                                                                                                                                                                                                                                                                                                      	SecondsUntilAutoPause *int32
                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                      	// The timeout action of a call to ModifyCurrentDBClusterCapacity, either
                                                                                                                                                                                                                                                                                                                                                                                                      	// ForceApplyCapacityChange or RollbackCapacityChange.
                                                                                                                                                                                                                                                                                                                                                                                                      	TimeoutAction *string
                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                        Shows the scaling configuration for an Aurora DB cluster in serverless DB engine mode. For more information, see Using Amazon Aurora Serverless (https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-serverless.html) in the Amazon Aurora User Guide.

                                                                                                                                                                                                                                                                                                                                                                                                        type SharedSnapshotQuotaExceededFault

                                                                                                                                                                                                                                                                                                                                                                                                        type SharedSnapshotQuotaExceededFault struct {
                                                                                                                                                                                                                                                                                                                                                                                                        	Message *string
                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                          You have exceeded the maximum number of accounts that you can share a manual DB snapshot with.

                                                                                                                                                                                                                                                                                                                                                                                                          func (*SharedSnapshotQuotaExceededFault) Error

                                                                                                                                                                                                                                                                                                                                                                                                          func (*SharedSnapshotQuotaExceededFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                                          func (*SharedSnapshotQuotaExceededFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                                          func (*SharedSnapshotQuotaExceededFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                                          func (e *SharedSnapshotQuotaExceededFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                                          type SnapshotQuotaExceededFault

                                                                                                                                                                                                                                                                                                                                                                                                          type SnapshotQuotaExceededFault struct {
                                                                                                                                                                                                                                                                                                                                                                                                          	Message *string
                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                            The request would result in the user exceeding the allowed number of DB snapshots.

                                                                                                                                                                                                                                                                                                                                                                                                            func (*SnapshotQuotaExceededFault) Error

                                                                                                                                                                                                                                                                                                                                                                                                            func (*SnapshotQuotaExceededFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                                            func (e *SnapshotQuotaExceededFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                                            func (*SnapshotQuotaExceededFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                                            func (*SnapshotQuotaExceededFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                                            func (e *SnapshotQuotaExceededFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                                            type SourceNotFoundFault

                                                                                                                                                                                                                                                                                                                                                                                                            type SourceNotFoundFault struct {
                                                                                                                                                                                                                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                              The requested source could not be found.

                                                                                                                                                                                                                                                                                                                                                                                                              func (*SourceNotFoundFault) Error

                                                                                                                                                                                                                                                                                                                                                                                                              func (e *SourceNotFoundFault) Error() string

                                                                                                                                                                                                                                                                                                                                                                                                              func (*SourceNotFoundFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                                              func (e *SourceNotFoundFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                                              func (*SourceNotFoundFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                                              func (e *SourceNotFoundFault) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                                              func (*SourceNotFoundFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                                              func (e *SourceNotFoundFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                                              type SourceRegion

                                                                                                                                                                                                                                                                                                                                                                                                              type SourceRegion struct {
                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                              	// The endpoint for the source AWS Region endpoint.
                                                                                                                                                                                                                                                                                                                                                                                                              	Endpoint *string
                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                              	// The name of the source AWS Region.
                                                                                                                                                                                                                                                                                                                                                                                                              	RegionName *string
                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                              	// The status of the source AWS Region.
                                                                                                                                                                                                                                                                                                                                                                                                              	Status *string
                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                              	// Whether the source AWS Region supports replicating automated backups to the
                                                                                                                                                                                                                                                                                                                                                                                                              	// current AWS Region.
                                                                                                                                                                                                                                                                                                                                                                                                              	SupportsDBInstanceAutomatedBackupsReplication bool
                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                Contains an AWS Region name as the result of a successful call to the DescribeSourceRegions action.

                                                                                                                                                                                                                                                                                                                                                                                                                type SourceType

                                                                                                                                                                                                                                                                                                                                                                                                                type SourceType string
                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                	SourceTypeDbInstance        SourceType = "db-instance"
                                                                                                                                                                                                                                                                                                                                                                                                                	SourceTypeDbParameterGroup  SourceType = "db-parameter-group"
                                                                                                                                                                                                                                                                                                                                                                                                                	SourceTypeDbSecurityGroup   SourceType = "db-security-group"
                                                                                                                                                                                                                                                                                                                                                                                                                	SourceTypeDbSnapshot        SourceType = "db-snapshot"
                                                                                                                                                                                                                                                                                                                                                                                                                	SourceTypeDbCluster         SourceType = "db-cluster"
                                                                                                                                                                                                                                                                                                                                                                                                                	SourceTypeDbClusterSnapshot SourceType = "db-cluster-snapshot"
                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                  Enum values for SourceType

                                                                                                                                                                                                                                                                                                                                                                                                                  func (SourceType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                  func (SourceType) Values() []SourceType<